Author: vkumar
Date: Thu Sep 25 06:27:53 2008
New Revision: 698962
URL: http://svn.apache.org/viewvc?rev=698962&view=rev
Log:
Implementing new methods in DefaultJetSpeedSynchronizer
synchronizeAll :- This will synchronize all entities from Ldap to database
synchronizePrincipalsByType :- This will synchronize based on given entity
Modified:
portals/jetspeed-2/portal/branches/security-refactoring/components/jetspeed-security/src/main/java/org/apache/jetspeed/security/mapping/ldap/dao/impl/SpringLDAPEntityDAO.java
portals/jetspeed-2/portal/branches/security-refactoring/components/jetspeed-security/src/main/java/org/apache/jetspeed/security/spi/impl/DefaultJetspeedSecuritySynchronizer.java
Modified:
portals/jetspeed-2/portal/branches/security-refactoring/components/jetspeed-security/src/main/java/org/apache/jetspeed/security/mapping/ldap/dao/impl/SpringLDAPEntityDAO.java
URL:
http://svn.apache.org/viewvc/portals/jetspeed-2/portal/branches/security-refactoring/components/jetspeed-security/src/main/java/org/apache/jetspeed/security/mapping/ldap/dao/impl/SpringLDAPEntityDAO.java?rev=698962&r1=698961&r2=698962&view=diff
==============================================================================
---
portals/jetspeed-2/portal/branches/security-refactoring/components/jetspeed-security/src/main/java/org/apache/jetspeed/security/mapping/ldap/dao/impl/SpringLDAPEntityDAO.java
(original)
+++
portals/jetspeed-2/portal/branches/security-refactoring/components/jetspeed-security/src/main/java/org/apache/jetspeed/security/mapping/ldap/dao/impl/SpringLDAPEntityDAO.java
Thu Sep 25 06:27:53 2008
@@ -94,7 +94,7 @@
DistinguishedName principalDN = new DistinguishedName(internalId);
principalDN.removeFirst();
internalId =principalDN.toString();
- Entity resultEntity = (Entity) ldapTemplate.lookup(internalId,
contextMapper);
+ Entity resultEntity = (Entity) ldapTemplate.lookup(internalId,
getContextMapper());
if (resultEntity != null)
{
resultSet.add(resultEntity);
Modified:
portals/jetspeed-2/portal/branches/security-refactoring/components/jetspeed-security/src/main/java/org/apache/jetspeed/security/spi/impl/DefaultJetspeedSecuritySynchronizer.java
URL:
http://svn.apache.org/viewvc/portals/jetspeed-2/portal/branches/security-refactoring/components/jetspeed-security/src/main/java/org/apache/jetspeed/security/spi/impl/DefaultJetspeedSecuritySynchronizer.java?rev=698962&r1=698961&r2=698962&view=diff
==============================================================================
---
portals/jetspeed-2/portal/branches/security-refactoring/components/jetspeed-security/src/main/java/org/apache/jetspeed/security/spi/impl/DefaultJetspeedSecuritySynchronizer.java
(original)
+++
portals/jetspeed-2/portal/branches/security-refactoring/components/jetspeed-security/src/main/java/org/apache/jetspeed/security/spi/impl/DefaultJetspeedSecuritySynchronizer.java
Thu Sep 25 06:27:53 2008
@@ -45,21 +45,15 @@
/**
* @author <a href="mailto:[EMAIL PROTECTED]">Dennis Dam</a>
- * @version $Id: DefaultJetspeedPrincipalSynchronizer.java 694772 2008-09-12
- * 18:39:51Z ddam $
+ * @version $Id$
*/
public class DefaultJetspeedSecuritySynchronizer implements
JetspeedSecuritySynchronizer
{
private static final Log logger =
LogFactory.getLog(DefaultJetspeedSecuritySynchronizer.class);
-
JetspeedPrincipalManagerProvider principalManagerProvider;
-
SecurityEntityManager securityEntityManager;
-
Collection<String> supportedExternalEntityTypes = Collections.emptyList();
-
Collection<SecurityEntityRelationType>
supportedExternalEntityRelationTypes = Collections.emptyList();
-
Map<String, Collection<SecurityEntityRelationType>> entityToRelationTypes
= Collections.emptyMap();
/**
@@ -70,7 +64,7 @@
{
this.principalManagerProvider = principalManagerProvider;
this.securityEntityManager = securityEntityManager;
-
+ createRelations();
}
public void synchronizeAll()
@@ -78,7 +72,9 @@
try
{
setSynchronizing(true);
- // TODO
+ synchronizePrincipalsByType(JetspeedPrincipalType.GROUP);
+ synchronizePrincipalsByType(JetspeedPrincipalType.ROLE);
+ synchronizePrincipalsByType(JetspeedPrincipalType.USER);
}
finally
{
@@ -90,8 +86,21 @@
{
try
{
- setSynchronizing(true);
- // TODO
+ if (principalTypeName.equalsIgnoreCase(JetspeedPrincipalType.USER))
+ {
+ setSynchronizing(true);
+ synchronizePrincipals(JetspeedPrincipalType.USER);
+ }
+ else if
(principalTypeName.equalsIgnoreCase(JetspeedPrincipalType.GROUP))
+ {
+ setSynchronizing(true);
+ synchronizePrincipals(JetspeedPrincipalType.GROUP);
+ }
+ else if
(principalTypeName.equalsIgnoreCase(JetspeedPrincipalType.ROLE))
+ {
+ setSynchronizing(true);
+ synchronizePrincipals(JetspeedPrincipalType.ROLE);
+ }
}
finally
{
@@ -99,19 +108,44 @@
}
}
+ private void synchronizePrincipals(String type)
+ {
+ Collection<Entity> entites =
securityEntityManager.getAllEntities(type);
+ Collection<String> skipEntities = new ArrayList<String>();
+ InternalSynchronizationState synchronizationState = new
InternalSynchronizationState(skipEntities);
+ for (Entity entity : entites)
+ {
+ recursiveSynchronizeEntity(entity, synchronizationState);
+ }
+ }
+
+ private void recursiveSynchronizeEntity(Entity entity,
InternalSynchronizationState syncState)
+ {
+ JetspeedPrincipal updatedPrincipal = null;
+ if (entity != null && !syncState.isProcessed(entity))
+ {
+ // mark as processed, to avoid nasty loops
+ syncState.setProcessed(entity);
+ // update / create corresponding JetspeedPrincipal first
+ updatedPrincipal = synchronizePrincipalAttributes(entity);
+ if (updatedPrincipal != null)
+ {
+ // Synchronizing Relations
+ synchronizePrincipalRelation(updatedPrincipal, entity,
syncState);
+ }
+ }
+ }
+
public void synchronizeUserPrincipal(String name)
{
try
{
setSynchronizing(true);
-
// don't process relations going towards users to avoid sync'ing
huge
// amounts of data.
// TODO: allow processing of required relations towards users.
- Collection<String> skipEntities = Arrays.asList(new String[]
- { JetspeedPrincipalType.USER});
+ Collection<String> skipEntities = Arrays.asList(new String[] {
JetspeedPrincipalType.USER });
recursiveSynchronizePrincipal(securityEntityManager.getEntity(JetspeedPrincipalType.USER,
name), new InternalSynchronizationState(skipEntities));
-
}
finally
{
@@ -126,49 +160,137 @@
{
// mark as processed, to avoid nasty loops
syncState.setProcessed(entity);
-
// update / create corresponding JetspeedPrincipal first
updatedPrincipal = synchronizePrincipalAttributes(entity);
+ if (updatedPrincipal != null)
+ {
+ // Synchronizing Relations
+ synchronizePrincipalRelation(updatedPrincipal, entity,
syncState);
+ }
+ }
+ return updatedPrincipal;
+ }
- if (updatedPrincipal != null &&
entityToRelationTypes.values().size() != 0)
+ protected JetspeedPrincipal synchronizePrincipalRelation(JetspeedPrincipal
principal, Entity entity, InternalSynchronizationState syncState)
+ {
+ if (entityToRelationTypes.values().size() != 0)
+ // loop through all relation types for this entity type
+ for (SecurityEntityRelationType relationTypeForThisEntity :
entityToRelationTypes.get(entity.getType()))
+ {
+ // check at what side of the relationship this entity
+ // represents (from or to) and check whether
+ // entities on the other side should be synchronized.Entity
+ // entity
+ if
(relationTypeForThisEntity.getFromEntityType().equals(entity.getType()))
+ {
+ if
(syncState.shouldFollowRelationTo(relationTypeForThisEntity.getToEntityType()))
+ {
+ Collection<String> updatedAssociationToNames =
synchronizeAssociations(relationTypeForThisEntity, entity, principal, true,
syncState);
+
synchronizeRemovedAssociations(updatedAssociationToNames,
relationTypeForThisEntity.getRelationType(), principal, true);
+ }
+ }
+ // the entity can represent either side or *both* sides of
+ // the relationship, so synchronize both ways.
+ if
(relationTypeForThisEntity.getToEntityType().equals(entity.getType()))
+ {
+ if
(syncState.shouldFollowRelationTo(relationTypeForThisEntity.getFromEntityType()))
+ {
+ Collection<String> updatedAssociationFromNames =
synchronizeAssociations(relationTypeForThisEntity, entity, principal, false,
syncState);
+
synchronizeRemovedAssociations(updatedAssociationFromNames,
relationTypeForThisEntity.getRelationType(), principal, false);
+ }
+ }
+ }
+ return principal;
+ }
+
+ protected JetspeedPrincipal
synchronizePrincipalRelations(JetspeedPrincipal principal, Entity entity,
InternalSynchronizationState syncState)
+ {
+ if (entityToRelationTypes.values().size() != 0)
+ // loop through all relation types for this entity type
+ for (SecurityEntityRelationType relationTypeForThisEntity :
entityToRelationTypes.get(entity.getType()))
{
- // loop through all relation types for this entity type
- for (SecurityEntityRelationType relationTypeForThisEntity :
entityToRelationTypes.get(entity.getType()))
+ // check at what side of the relationship this entity
+ // represents (from or to) and check whether
+ // entities on the other side should be synchronized.Entity
+ // entity
+ if
(relationTypeForThisEntity.getFromEntityType().equals(entity.getType()))
{
- // check at what side of the relationship this entity
- // represents (from or to) and check whether
- // entities on the other side should be synchronized.Entity
- // entity
- if
(relationTypeForThisEntity.getFromEntityType().equals(entity.getType())){
- Collection<String> updatedAssociationToNames =
synchronizeAddedAssociations(relationTypeForThisEntity,entity,updatedPrincipal,true,syncState);
-
synchronizeRemovedAssociations(updatedAssociationToNames,
relationTypeForThisEntity.getRelationType(), updatedPrincipal, true);
- }
-
- // the entity can represent either side or *both* sides of
- // the relationship, so synchronize both ways.
- if
(relationTypeForThisEntity.getToEntityType().equals(entity.getType()))
+ if
(syncState.shouldFollowRelationTo(relationTypeForThisEntity.getToEntityType()))
{
- Collection<String> updatedAssociationFromNames =
synchronizeAddedAssociations(relationTypeForThisEntity,entity,updatedPrincipal,false,syncState);
-
synchronizeRemovedAssociations(updatedAssociationFromNames,
relationTypeForThisEntity.getRelationType(), updatedPrincipal, false);
+ Collection<String> updatedAssociationToNames =
synchronizeAddedAssociations(relationTypeForThisEntity, entity, principal, true,
+
syncState);
+
synchronizeRemovedAssociations(updatedAssociationToNames,
relationTypeForThisEntity.getRelationType(), principal, true);
+ }
+ }
+ // the entity can represent either side or *both* sides of
+ // the relationship, so synchronize both ways.
+ if
(relationTypeForThisEntity.getToEntityType().equals(entity.getType()))
+ {
+ if
(syncState.shouldFollowRelationTo(relationTypeForThisEntity.getFromEntityType()))
+ {
+ Collection<String> updatedAssociationFromNames =
synchronizeAddedAssociations(relationTypeForThisEntity, entity, principal,
false,
+
syncState);
+
synchronizeRemovedAssociations(updatedAssociationFromNames,
relationTypeForThisEntity.getRelationType(), principal, false);
}
}
}
+ return principal;
+ }
+ protected Collection<String>
synchronizeAssociations(SecurityEntityRelationType relationTypeForThisEntity,
Entity entity, JetspeedPrincipal principal,
+ boolean
entityIsFromEntity, InternalSynchronizationState syncState)
+ {
+ Collection<String> externalRelatedEntityIds = null;
+ Collection<Entity> relatedEntities = entityIsFromEntity ?
securityEntityManager.getRelatedEntitiesFrom(entity, relationTypeForThisEntity)
+ :
securityEntityManager.getRelatedEntitiesTo(entity, relationTypeForThisEntity);
+ externalRelatedEntityIds = new ArrayList<String>();
+ for (Entity relatedEntity : relatedEntities)
+ {
+ Entity fromEntity = entityIsFromEntity ? entity : relatedEntity;
+ Entity toEntity = entityIsFromEntity ? relatedEntity : entity;
+ if (!syncState.isRelationProcessed(relationTypeForThisEntity,
fromEntity, toEntity))
+ {
+ // first flag the relation as processed to
+ // prevent synchronizing the same relation from
+ // the other side.
+ syncState.setRelationProcessed(relationTypeForThisEntity,
fromEntity, toEntity, entityIsFromEntity);
+ // first create/update principal
+ // JetspeedPrincipal relatedPrincipal =
recursiveSynchronizePrincipal(relatedEntity, syncState);
+ JetspeedPrincipal relatedPrincipal = null;
+ JetspeedPrincipalManager principalManager =
principalManagerProvider
+
.getManager(principalManagerProvider
+
.getPrincipalType(relatedEntity
+
.getType()));
+ if (principalManager != null)
+ {
+ relatedPrincipal =
principalManager.getPrincipal(relatedEntity.getId());
+ }
+ // .. then update associations to / from it
+ JetspeedPrincipal fromPrincipal = entityIsFromEntity ?
principal : relatedPrincipal;
+ JetspeedPrincipal toPrincipal = entityIsFromEntity ?
relatedPrincipal : principal;
+ // does association exist in DB ?
+ if (relatedPrincipal != null &&
!associationExists(fromPrincipal, toPrincipal,
relationTypeForThisEntity.getRelationType()))
+ {
+ synchronizeAddedPrincipalAssocation(fromPrincipal,
toPrincipal, relationTypeForThisEntity.getRelationType());
+ externalRelatedEntityIds.add(relatedPrincipal.getName());
+ }
+ }
}
- return updatedPrincipal;
+ return externalRelatedEntityIds;
}
- protected Collection<String>
synchronizeAddedAssociations(SecurityEntityRelationType
relationTypeForThisEntity, Entity entity, JetspeedPrincipal principal, boolean
entityIsFromEntity, InternalSynchronizationState syncState){
- Collection<String> externalRelatedEntityIds=null;
- Collection<Entity> relatedEntities = entityIsFromEntity ?
- securityEntityManager.getRelatedEntitiesFrom(entity,
relationTypeForThisEntity) :
- securityEntityManager.getRelatedEntitiesTo(entity,
relationTypeForThisEntity);
+ protected Collection<String>
synchronizeAddedAssociations(SecurityEntityRelationType
relationTypeForThisEntity, Entity entity, JetspeedPrincipal principal,
+ boolean
entityIsFromEntity, InternalSynchronizationState syncState)
+ {
+ Collection<String> externalRelatedEntityIds = null;
+ Collection<Entity> relatedEntities = entityIsFromEntity ?
securityEntityManager.getRelatedEntitiesFrom(entity, relationTypeForThisEntity)
+ :
securityEntityManager.getRelatedEntitiesTo(entity, relationTypeForThisEntity);
externalRelatedEntityIds = new ArrayList<String>();
for (Entity relatedEntity : relatedEntities)
- {
+ {
Entity fromEntity = entityIsFromEntity ? entity : relatedEntity;
- Entity toEntity = entityIsFromEntity ? relatedEntity : entity ;
- if (syncState.isRelationProcessed(relationTypeForThisEntity,
fromEntity, toEntity))
+ Entity toEntity = entityIsFromEntity ? relatedEntity : entity;
+ if (!syncState.isRelationProcessed(relationTypeForThisEntity,
fromEntity, toEntity))
{
// first flag the relation as processed to
// prevent synchronizing the same relation from
@@ -189,9 +311,9 @@
}
return externalRelatedEntityIds;
}
-
+
protected void synchronizeRemovedAssociations(Collection<String>
externalRelatedEntityIds, String associationName, JetspeedPrincipal principal,
- boolean isFromPrincipal)
+ boolean isFromPrincipal)
{
// check whether associations were removed in external store (e.g.
// LDAP), but still present in the DB
@@ -200,7 +322,8 @@
if (isFromPrincipal)
{
relatedToPrincipals =
principalManager.getAssociatedFrom(principal.getName(), principal.getType(),
associationName);
- } else
+ }
+ else
{
relatedToPrincipals =
principalManager.getAssociatedTo(principal.getName(), principal.getType(),
associationName);
}
@@ -214,35 +337,45 @@
if (isFromPrincipal)
{
principalManager.removeAssociation(principal,
relatedPrincipal, associationName);
- } else
+ }
+ else
{
principalManager.removeAssociation(relatedPrincipal,
principal, associationName);
}
- } catch (SecurityException e){
- if (isFromPrincipal){
- logger.error("Unexpected SecurityException trying to
remove
("+principal.getType().getName()+","+relatedPrincipal.getType().getName()+","+associationName+")
association during synchronization.", e);
- } else {
- logger.error("Unexpected SecurityException trying to
remove
("+relatedPrincipal.getType().getName()+","+principal.getType().getName()+","+associationName+")
association during synchronization.", e);
+ }
+ catch (SecurityException e)
+ {
+ if (isFromPrincipal)
+ {
+ logger.error("Unexpected SecurityException trying to
remove (" + principal.getType().getName() + "," +
+ relatedPrincipal.getType().getName() +
"," + associationName + ") association during synchronization.", e);
+ }
+ else
+ {
+ logger.error("Unexpected SecurityException trying to
remove (" + relatedPrincipal.getType().getName() + "," +
+ principal.getType().getName() + "," +
associationName + ") association during synchronization.", e);
}
-
- }
+ }
}
}
}
- protected boolean associationExists(JetspeedPrincipal fromPrincipal,
JetspeedPrincipal toPrincipal, String associationName){
+ protected boolean associationExists(JetspeedPrincipal fromPrincipal,
JetspeedPrincipal toPrincipal, String associationName)
+ {
JetspeedPrincipalManager principalManager =
principalManagerProvider.getManager(fromPrincipal.getType());
List<String> toPrincipals =
principalManager.getAssociatedNamesFrom(fromPrincipal.getName(),
fromPrincipal.getType(), associationName);
return toPrincipals.contains(toPrincipal.getName());
}
-
+
protected void synchronizeAddedPrincipalAssocation(JetspeedPrincipal
fromPrincipal, JetspeedPrincipal toPrincipal, String associationName)
{
JetspeedPrincipalManager principalManager =
principalManagerProvider.getManager(fromPrincipal.getType());
try
{
principalManager.addAssociation(fromPrincipal, toPrincipal,
associationName);
- } catch (SecurityException e){
+ }
+ catch (SecurityException e)
+ {
logger.error("Unexpected SecurityException during
synchronization.", e);
}
}
@@ -261,8 +394,19 @@
// principal does not exist yet, create it using the Jetspeed
// principal manager
updatedPrincipal =
principalManager.newPrincipal(entity.getId(), true);
+ try
+ {
+ principalManager.addPrincipal(updatedPrincipal, null);
+ }
+ catch (SecurityException sexp)
+ {
+ if (logger.isErrorEnabled())
+ {
+ logger.error("Unexpected exception in adding new
pricipal of type " + updatedPrincipal.getType().getName() + ".", sexp);
+ }
+ }
attrsToBeUpdated.addAll(mappedEntityAttrs.values());
- }
+ }
else if (updatedPrincipal.isMapped())
{
SecurityAttributes principalAttrs =
updatedPrincipal.getSecurityAttributes();
@@ -276,7 +420,7 @@
{
// TODO : multi-valued Principal attrs are not yet
// supported
- }
+ }
else
{
if
(!StringUtils.equals(principalAttr.getStringValue(), entityAttr.getValue()))
@@ -284,17 +428,15 @@
attrsToBeUpdated.add(entityAttr);
}
}
- }
+ }
else
{
attrsToBeUpdated.add(entityAttr);
}
}
}
-
SecurityAttributes principalAttrs =
updatedPrincipal.getSecurityAttributes();
Map<String, SecurityAttributeType> securityAttrTypes =
principalAttrs.getSecurityAttributeTypes().getAttributeTypeMap();
-
// Step 1. update principal's attributes
for (Attribute addedEntityAttr : attrsToBeUpdated)
{
@@ -308,15 +450,16 @@
{
principalAttr =
principalAttrs.getAttribute(addedEntityAttr.getMappedName(), true);
}
- if (principalAttr!=null)
principalAttr.setStringValue(addedEntityAttr.getValue());
- }
+ if (principalAttr != null)
+
principalAttr.setStringValue(addedEntityAttr.getValue());
+ }
catch (SecurityException e)
{
if (logger.isErrorEnabled())
{
logger.error("Unexpected exception for attribute "
+ addedEntityAttr.getMappedName() + ".", e);
}
- }
+ }
}
}
if (updatedPrincipal.isMapped())
@@ -346,15 +489,15 @@
try
{
principalManager.updatePrincipal(updatedPrincipal);
- }
+ }
catch (SecurityException e)
{
- logger.error("Unexpected SecurityException: could not
synchronize principal " + updatedPrincipal.getName() + " of type " +
updatedPrincipal.getType().getName(), e);
- }
+ logger.error("Unexpected SecurityException: could not
synchronize principal " + updatedPrincipal.getName() + " of type " +
+ updatedPrincipal.getType().getName(), e);
+ }
}
}
-
- }
+ }
else
{
// TODO throw proper exception
@@ -362,18 +505,18 @@
return updatedPrincipal;
}
- private void setSynchronizing(boolean sync){
+ private void setSynchronizing(boolean sync)
+ {
SynchronizationStateAccess.setSynchronizing(sync ? Boolean.TRUE :
Boolean.FALSE);
}
-
+
public void setPrincipalManagerProvider(JetspeedPrincipalManagerProvider
principalManagerProvider)
{
this.principalManagerProvider = principalManagerProvider;
}
- public void setSecurityEntityManager(SecurityEntityManager
securityEntityManager)
+ private void createRelations()
{
- this.securityEntityManager = securityEntityManager;
supportedExternalEntityTypes =
securityEntityManager.getSupportedEntityTypes();
supportedExternalEntityRelationTypes =
securityEntityManager.getSupportedEntityRelationTypes();
entityToRelationTypes = new HashMap<String,
Collection<SecurityEntityRelationType>>();
@@ -385,13 +528,10 @@
private class InternalSynchronizationState
{
-
// entity type to processed entity IDs map
Map<String, Set<String>> processedEntities = new HashMap<String,
Set<String>>();
-
// map relation type to a "from entity" -> "to entity" mapping
Map<SecurityEntityRelationType, Map<String, Collection<String>>>
processedEntityRelationsFromTo = new HashMap<SecurityEntityRelationType,
Map<String, Collection<String>>>();
-
// Entity types which are not processed
// This is implemented as not following relations towards entities of
// these types. E.g. if skipEntities contains the "user" type, and
@@ -414,6 +554,11 @@
return processedEntitiesByType != null &&
processedEntitiesByType.contains(entity.getId());
}
+ private boolean shouldFollowRelationTo(String relationType)
+ {
+ return !skipEntities.contains(relationType);
+ }
+
private void setProcessed(Entity entity)
{
Set<String> processedEntitiesByType =
processedEntities.get(entity.getType());
@@ -424,14 +569,6 @@
processedEntitiesByType.add(entity.getId());
}
- private boolean isRelationProcessed(SecurityEntityRelationType
relationType, Entity startEntity, Entity endEntity, boolean startEntityIsFrom){
- if (startEntityIsFrom){
- return isRelationProcessed(relationType, startEntity,
endEntity);
- } else {
- return isRelationProcessed(relationType, endEntity,
startEntity);
- }
- }
-
private boolean isRelationProcessed(SecurityEntityRelationType
relationType, Entity fromEntity, Entity toEntity)
{
Map<String, Collection<String>> e2eMap =
processedEntityRelationsFromTo.get(relationType);
@@ -443,14 +580,18 @@
return false;
}
- private void setRelationProcessed(SecurityEntityRelationType
relationType, Entity startEntity, Entity endEntity, boolean startEntityIsFrom){
- if (startEntityIsFrom){
+ private void setRelationProcessed(SecurityEntityRelationType
relationType, Entity startEntity, Entity endEntity, boolean startEntityIsFrom)
+ {
+ if (startEntityIsFrom)
+ {
setRelationProcessed(relationType, startEntity, endEntity);
- } else {
+ }
+ else
+ {
setRelationProcessed(relationType, endEntity, startEntity);
}
}
-
+
private void setRelationProcessed(SecurityEntityRelationType
relationType, Entity fromEntity, Entity toEntity)
{
Map<String, Collection<String>> e2eMap =
processedEntityRelationsFromTo.get(relationType);
@@ -467,7 +608,5 @@
}
endIds.add(toEntity.getId());
}
-
}
-
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
