Java tutorial
/* * Copyright (C) 2005-2012 BetaCONCEPT Limited * * This file is part of Astroboa. * * Astroboa is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Astroboa is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with Astroboa. If not, see <http://www.gnu.org/licenses/>. */ package org.betaconceptframework.astroboa.engine.jcr.dao; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; import javax.jcr.ItemNotFoundException; import javax.jcr.Node; import javax.jcr.NodeIterator; import javax.jcr.PathNotFoundException; import javax.jcr.RepositoryException; import javax.jcr.Session; import javax.jcr.ValueFormatException; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.collections.MapUtils; import org.apache.commons.lang.StringUtils; import org.betaconceptframework.astroboa.api.model.CmsApiConstants; import org.betaconceptframework.astroboa.api.model.CmsRepositoryEntity; import org.betaconceptframework.astroboa.api.model.RepositoryUser; import org.betaconceptframework.astroboa.api.model.RepositoryUserType; import org.betaconceptframework.astroboa.api.model.Space; import org.betaconceptframework.astroboa.api.model.Taxonomy; import org.betaconceptframework.astroboa.api.model.definition.Localization; import org.betaconceptframework.astroboa.api.model.exception.CmsException; import org.betaconceptframework.astroboa.api.model.io.ImportConfiguration; import org.betaconceptframework.astroboa.api.model.io.ImportConfiguration.PersistMode; import org.betaconceptframework.astroboa.api.model.query.criteria.ContentObjectCriteria; import org.betaconceptframework.astroboa.api.model.query.criteria.RepositoryUserCriteria; import org.betaconceptframework.astroboa.api.model.query.criteria.SpaceCriteria; import org.betaconceptframework.astroboa.api.model.query.render.RenderProperties; import org.betaconceptframework.astroboa.engine.cache.regions.JcrQueryCacheRegion; import org.betaconceptframework.astroboa.engine.database.dao.CmsRepositoryEntityAssociationDao; import org.betaconceptframework.astroboa.engine.jcr.query.CmsQueryHandler; import org.betaconceptframework.astroboa.engine.jcr.query.CmsQueryResult; import org.betaconceptframework.astroboa.engine.jcr.renderer.RepositoryUserRenderer; import org.betaconceptframework.astroboa.engine.jcr.util.CmsLocalizationUtils; import org.betaconceptframework.astroboa.engine.jcr.util.CmsRepositoryEntityUtils; import org.betaconceptframework.astroboa.engine.jcr.util.Context; import org.betaconceptframework.astroboa.engine.jcr.util.EntityAssociationDeleteHelper; import org.betaconceptframework.astroboa.engine.jcr.util.EntityAssociationUpdateHelper; import org.betaconceptframework.astroboa.engine.jcr.util.JcrNodeUtils; import org.betaconceptframework.astroboa.engine.jcr.util.RendererUtils; import org.betaconceptframework.astroboa.engine.jcr.util.SpaceUtils; import org.betaconceptframework.astroboa.model.factory.CmsCriteriaFactory; import org.betaconceptframework.astroboa.model.factory.CmsRepositoryEntityFactoryForActiveClient; import org.betaconceptframework.astroboa.model.impl.RepositoryUserImpl; import org.betaconceptframework.astroboa.model.impl.item.CmsBuiltInItem; import org.betaconceptframework.astroboa.util.CmsConstants; import org.springframework.beans.factory.annotation.Autowired; /** * * @author Gregory Chomatas (gchomatas@betaconcept.com) * @author Savvas Triantafyllou (striantafyllou@betaconcept.com) * */ public class RepositoryUserDao extends JcrDaoSupport { @Autowired private CmsRepositoryEntityUtils cmsRepositoryEntityUtils; @Autowired private JcrQueryCacheRegion jcrQueryCacheRegion; @Autowired private RendererUtils rendererUtils; @Autowired private CmsQueryHandler cmsQueryHandler; @Autowired private RepositoryUserRenderer repositoryUserRenderer; @Autowired private CmsLocalizationUtils cmsLocalizationUtils; @Autowired private ContentObjectDao contentObjectDao; @Autowired private SpaceUtils spaceUtils; /** * Provides localized labels for folksonomies */ private Localization defaultFolksonomyLocalization; /** * Provides localized labels for Spaces */ private Localization defaultSpaceLocalization; @Autowired private CmsRepositoryEntityAssociationDao cmsRepositoryEntityAssociationDao; @Autowired private ImportDao importDao; public void setDefaultSpaceLocalization(Localization defaultSpaceLocalization) { this.defaultSpaceLocalization = defaultSpaceLocalization; } public void setDefaultFolksonomyLocalization(Localization defaultFolksonomyLocalization) { this.defaultFolksonomyLocalization = defaultFolksonomyLocalization; } public RepositoryUser getSystemRepositoryUser() { return getRepositoryUser(CmsApiConstants.SYSTEM_REPOSITORY_USER_EXTRENAL_ID); } public void removeRepositoryUserAndOwnedObjects(String repositoryUserId) { removeRepositoryUser(repositoryUserId, null, true); } private void removeRepositoryUser(String repositoryUserId, RepositoryUser alternativeUser, boolean removeObjectsWhoseOwnerIsTheUserToBeDeleted) { Context context = null; try { Session session = getSession(); if (StringUtils.isBlank(repositoryUserId)) throw new ItemNotFoundException("Undefined repository user id " + repositoryUserId); // Retrieve user node to be removed Node repositoryUserNode = cmsRepositoryEntityUtils.retrieveUniqueNodeForRepositoryUser(session, repositoryUserId); if (repositoryUserNode == null) throw new CmsException("No repository User found with Id " + repositoryUserId); if (repositoryUserNode.hasProperty(CmsBuiltInItem.ExternalId.getJcrName())) { String externalId = repositoryUserNode.getProperty(CmsBuiltInItem.ExternalId.getJcrName()) .getString(); if (CmsApiConstants.SYSTEM_REPOSITORY_USER_EXTRENAL_ID.equals(externalId)) { throw new CmsException("Invalid delete operation. SYSTEM RepositoryUser cannot be deleted."); } } if (alternativeUser == null && !removeObjectsWhoseOwnerIsTheUserToBeDeleted) { throw new CmsException("No alternative user has been provided"); } context = new Context(cmsRepositoryEntityUtils, cmsQueryHandler, session); //Save any alternative user if (alternativeUser != null) { updateRepositoryUserNode(session, alternativeUser, context); } //remove all node References removeReferencesForRepositoryUser(session, alternativeUser, removeObjectsWhoseOwnerIsTheUserToBeDeleted, repositoryUserId, context); //remove user node repositoryUserNode.remove(); session.save(); //Notify cache //jcrQueryCacheRegion.removeRegion(); } catch (Exception e) { throw new CmsException(e); } finally { if (context != null) { context.dispose(); context = null; } } } public void removeRepositoryUser(String repositoryUserId, RepositoryUser alternativeUser) { removeRepositoryUser(repositoryUserId, alternativeUser, (alternativeUser == null)); } public RepositoryUser saveRepositoryUser(Object repositoryUserSource) { if (repositoryUserSource == null) { throw new CmsException("Cannot save an empty RepositoryUser !"); } if (repositoryUserSource instanceof String) { //Use importer to unmarshal String to RepositoryUser //and to save it as well. //What is happened is that importDao will create a RepositoryUser //and will pass it here again to save it. ImportConfiguration configuration = ImportConfiguration.repositoryUser() .persist(PersistMode.PERSIST_MAIN_ENTITY).build(); return importDao.importRepositoryUser((String) repositoryUserSource, configuration); } if (!(repositoryUserSource instanceof RepositoryUser)) { throw new CmsException("Expecting either String or RepositoryUser and not " + repositoryUserSource.getClass().getName()); } RepositoryUser repositoryUser = (RepositoryUser) repositoryUserSource; Context context = null; try { Session session = getSession(); context = new Context(cmsRepositoryEntityUtils, cmsQueryHandler, session); updateRepositoryUserNode(session, repositoryUser, context); session.save(); //Inform cache //jcrQueryCacheRegion.removeRegion(); return repositoryUser; } catch (Exception e) { throw new CmsException(e); } finally { if (context != null) { context.dispose(); context = null; } } } public List<RepositoryUser> searchRepositoryUsers(RepositoryUserCriteria repositoryUserCriteria) { Session session = null; if (repositoryUserCriteria == null) throw new CmsException("Null repository user criteria"); try { //For some reason user has asked for 0 limit //Returned an empty list. No need to perform the //query. this method output must be changed to CmsOutcome //in order to provide user with the total result count //even when limit is 0 , that is no result should be returned if (repositoryUserCriteria.getLimit() == 0) { return new ArrayList<RepositoryUser>(); } List<RepositoryUser> repositoryUserList = null; if (repositoryUserCriteria.isCacheable()) { //Search in cache repositoryUserList = (List<RepositoryUser>) jcrQueryCacheRegion .getJcrQueryResults(repositoryUserCriteria); } if (repositoryUserList != null) return repositoryUserList; else { session = getSession(); repositoryUserList = new ArrayList<RepositoryUser>(); //Need new instance in case during rendering render instructions are updated RenderProperties renderPropertiesForCache = rendererUtils .copyRenderPropertiesFromCriteria(repositoryUserCriteria); //CmsQueryResultSecurityHandler cmsQueryResultSecurityHandler = new CmsQueryResultSecurityHandler(cmsQueryHandler, // repositoryUserCriteria,session, accessManager); CmsQueryResult cmsQueryResult = cmsQueryHandler.getNodesFromXPathQuery(session, repositoryUserCriteria); NodeIterator nodeIterator = cmsQueryResult.getNodeIterator(); Map<String, CmsRepositoryEntity> cachedRepositoryEntities = new HashMap<String, CmsRepositoryEntity>(); List<String> repositoryUserIdsForCache = new ArrayList<String>(); while (nodeIterator.hasNext()) { RepositoryUser repositoryUser = renderRepositoryUserFromNode(nodeIterator.nextNode(), session, repositoryUserCriteria.getRenderProperties(), cachedRepositoryEntities); repositoryUserList.add(repositoryUser); repositoryUserIdsForCache.add(repositoryUser.getId()); } //Cache results if (repositoryUserCriteria.isCacheable()) { if (!StringUtils.isBlank(repositoryUserCriteria.getXPathQuery()) && CollectionUtils.isNotEmpty(repositoryUserList)) { jcrQueryCacheRegion.cacheJcrQueryResults(repositoryUserCriteria, repositoryUserList, renderPropertiesForCache); } } return repositoryUserList; } } catch (Exception e) { throw new CmsException(e); } } public RepositoryUser renderRepositoryUserFromNode(Node node, Session session, RenderProperties renderProperties, Map<String, CmsRepositoryEntity> cachedRepositoryEntities) throws RepositoryException { return repositoryUserRenderer.renderRepositoryUserNode(node, renderProperties, session, cachedRepositoryEntities); } private void updateRepositoryUserNode(Session session, RepositoryUser repositoryUser, Context context) throws RepositoryException { Node repositoryUserNode = retrieveOrCreateRepositoryUserNode(session, repositoryUser); populateRepositoryUserNode(repositoryUserNode, repositoryUser, session, context); } private Node retrieveOrCreateRepositoryUserNode(Session session, RepositoryUser repositoryUser) throws RepositoryException { //1. ExternalId is not provided. Search user using its identifier if (StringUtils.isBlank(repositoryUser.getExternalId())) { if (repositoryUser.getId() == null) { throw new CmsException("Repository user has not external id and no cms identifier"); } else { //Search for a repository user node with provided identifier Node repositoryUserNode = cmsRepositoryEntityUtils.retrieveUniqueNodeForRepositoryUser(session, repositoryUser.getId()); if (repositoryUserNode != null) { return repositoryUserNode; } else { throw new CmsException("Could not update repository user " + repositoryUser.toString() + " because no repository user with such id is found in repository and externalId is not provided"); } } } else { //2.External Id is provided. //a. Check external Id belongs to SYSTEM user if (CmsApiConstants.SYSTEM_REPOSITORY_USER_EXTRENAL_ID.equals(repositoryUser.getExternalId())) { //SYSTEM user is updated. Retrieve system repository user node //In case repositoryUser instance has an identifier ignore it return retrieveSystemRepositoryUserNode(session, true); } else { //Check how many users exist with the same external id Node existingRepositoryUserNode = checkForDuplicateExternalId(repositoryUser, session); if (existingRepositoryUserNode != null) { return existingRepositoryUserNode; } else { //No node found with provided identifier and/or external Id. Create new node return createRepositoryUserNode(repositoryUser, session); } } } } public RepositoryUser createSystemRepositoryUser() { Context context = null; try { Session session = getSession(); if (retrieveSystemRepositoryUserNode(session, false) != null) { throw new Exception("RepositoryUser SYSTEM already exists"); } RepositoryUser systemUser = CmsRepositoryEntityFactoryForActiveClient.INSTANCE.getFactory() .newRepositoryUser(); systemUser.setExternalId(CmsApiConstants.SYSTEM_REPOSITORY_USER_EXTRENAL_ID); systemUser.setLabel(CmsApiConstants.SYSTEM_REPOSITORY_USER_LABEL); Node systemUserNode = createRepositoryUserNode(systemUser, session); context = new Context(cmsRepositoryEntityUtils, cmsQueryHandler, session); populateRepositoryUserNode(systemUserNode, systemUser, session, context); session.save(); return systemUser; } catch (Exception e) { throw new CmsException(e); } finally { if (context != null) { context.dispose(); context = null; } } } private Node retrieveSystemRepositoryUserNode(Session session, boolean throwExceptionIfNotFound) throws RepositoryException { RepositoryUserCriteria userCriteria = CmsCriteriaFactory.newRepositoryUserCriteria(); userCriteria.doNotCacheResults(); userCriteria.setLimit(1); userCriteria.addExternalIdEqualsCriterion(CmsApiConstants.SYSTEM_REPOSITORY_USER_EXTRENAL_ID); CmsQueryResult systemUserQueryResult = cmsQueryHandler.getNodesFromXPathQuery(session, userCriteria); if (systemUserQueryResult == null || systemUserQueryResult.getTotalRowCount() == 0) { if (throwExceptionIfNotFound) { throw new RepositoryException("Problem with locating system repository user node. Query " + userCriteria.getXPathQuery() + " did not returned 1 node"); } else { return null; } } else if (systemUserQueryResult.getTotalRowCount() == 1) { return systemUserQueryResult.getNodeIterator().nextNode(); } else { throw new RepositoryException( "Problem with locating system repository user node. Found more than one jcr nodes representing system repository user"); } } private Node createRepositoryUserNode(RepositoryUser repositoryUser, Session session) throws RepositoryException { Node repositoryUserNode = JcrNodeUtils.addRepositoryUserNode(session); //Create CmsIdentifier cmsRepositoryEntityUtils.createCmsIdentifier(repositoryUserNode, repositoryUser, true); return repositoryUserNode; } private void populateRepositoryUserNode(Node repositoryUserNode, RepositoryUser repositoryUser, Session session, Context context) throws RepositoryException { String repositoryUserExternalId = repositoryUser.getExternalId(); //External Id. Update it only if it does not exists if (!repositoryUserNode.hasProperty(CmsBuiltInItem.ExternalId.getJcrName())) { repositoryUserNode.setProperty(CmsBuiltInItem.ExternalId.getJcrName(), repositoryUserExternalId); } //or it is not SYSTEM RepositoyUser ExternalId and it is not the same with the one existed else { String existingExternalId = repositoryUserNode.getProperty(CmsBuiltInItem.ExternalId.getJcrName()) .getString(); boolean repositoryUserExternalIdIsDifferentThanExisting = !existingExternalId .equals(repositoryUserExternalId); if (repositoryUserExternalIdIsDifferentThanExisting) { if (CmsApiConstants.SYSTEM_REPOSITORY_USER_EXTRENAL_ID.equals(existingExternalId)) { throw new RepositoryException( "Invalid operation. Tried to update SYSTEM repository user externalId."); } else { repositoryUserNode.setProperty(CmsBuiltInItem.ExternalId.getJcrName(), repositoryUserExternalId); } } } //Label repositoryUserNode.setProperty(CmsBuiltInItem.Label.getJcrName(), repositoryUser.getLabel()); //User Type if (repositoryUser.getUserType() == null) { repositoryUser.setUserType(RepositoryUserType.User); } repositoryUserNode.setProperty(CmsBuiltInItem.UserType.getJcrName(), repositoryUser.getUserType().toString()); populateSpace(repositoryUser, repositoryUserNode, session, context); populateFolksonomy(repositoryUser, repositoryUserNode, session); // TODO Preferences Implement method populatePreferences(repositoryUser, repositoryUserNode); } private Node checkForDuplicateExternalId(RepositoryUser repositoryUserToBeSaved, Session session) throws RepositoryException, ValueFormatException, PathNotFoundException { RepositoryUserCriteria userCriteria = CmsCriteriaFactory.newRepositoryUserCriteria(); userCriteria.doNotCacheResults(); userCriteria.setLimit(2); userCriteria.addExternalIdEqualsCriterion(repositoryUserToBeSaved.getExternalId()); CmsQueryResult usersWithTheSameExternalId = cmsQueryHandler.getNodesFromXPathQuery(session, userCriteria); if (usersWithTheSameExternalId != null) { if (usersWithTheSameExternalId.getTotalRowCount() > 1) { throw new RepositoryException("Found more than one repository users with the same external id " + repositoryUserToBeSaved.getExternalId()); } if (usersWithTheSameExternalId.getTotalRowCount() == 1) { if (repositoryUserToBeSaved.getId() == null) { throw new RepositoryException("A repository user with the same external id " + repositoryUserToBeSaved.getExternalId() + " already exists."); } else { Node existingRepositoryUserNode = usersWithTheSameExternalId.getNodeIterator().nextNode(); //Must be the same node if (!existingRepositoryUserNode.hasProperty(CmsBuiltInItem.CmsIdentifier.getJcrName()) || !existingRepositoryUserNode.getProperty(CmsBuiltInItem.CmsIdentifier.getJcrName()) .getString().equals(repositoryUserToBeSaved.getId())) { throw new RepositoryException("A repository user with the same external id " + repositoryUserToBeSaved.getExternalId() + " already exists."); } return existingRepositoryUserNode; } } } //No other node found with the same external id. in case identifier is provided return null; } private void populateFolksonomy(RepositoryUser repositoryUser, Node repositoryUserNode, Session session) throws RepositoryException { Taxonomy repositoryUserFolksonomy = repositoryUser.getFolksonomy(); if (repositoryUserFolksonomy == null) { ((RepositoryUserImpl) repositoryUser) .setFolksonomy(cmsRepositoryEntityFactoryForActiveClient.newTaxonomy()); repositoryUserFolksonomy = repositoryUser.getFolksonomy(); } //Folksonomy node should have already been created. No need to check for it existence Node folksonomyNode = repositoryUserNode.getNode(CmsBuiltInItem.Folksonomy.getJcrName()); //If repository user folksonomy has no localized labels use the default if (!repositoryUserFolksonomy.hasLocalizedLabels() && MapUtils.isNotEmpty(defaultFolksonomyLocalization.getLocalizedLabels())) { repositoryUserFolksonomy.getLocalizedLabels() .putAll(defaultFolksonomyLocalization.getLocalizedLabels()); } //Update localization for repository user folksonomy cmsLocalizationUtils.updateCmsLocalization(repositoryUserFolksonomy, folksonomyNode); // In case repository user is a new user and its folksonomy does not have a name String providedFolksonomyName = repositoryUserFolksonomy.getName(); if (StringUtils.isBlank(providedFolksonomyName)) { repositoryUserFolksonomy.setName(folksonomyNode.getName()); } else { //Folksonomy Name is a fixed name and should never change if (!folksonomyNode.getName().equals(providedFolksonomyName)) { throw new RepositoryException("Invalid folksonomy name " + providedFolksonomyName); } } //Create Folksonomy Identifier if folksonomy is a new one if (folksonomyNode.isNew()) { if (cmsRepositoryEntityUtils.hasCmsIdentifier(folksonomyNode)) { //This should never happen throw new CmsException("Folskonomy jcr node is new but an idnetifier property already exists"); } //Create a Astroboa identifier for folskonomy or use the one provided cmsRepositoryEntityUtils.createCmsIdentifier(folksonomyNode, repositoryUserFolksonomy, true); } else { //Folksonomy node is not new. Check that an identifier exists if (!cmsRepositoryEntityUtils.hasCmsIdentifier(folksonomyNode)) { cmsRepositoryEntityUtils.createCmsIdentifier(folksonomyNode, repositoryUserFolksonomy, true); } else { String folksonomyIdentifier = cmsRepositoryEntityUtils.getCmsIdentifier(folksonomyNode); //User has provided an identifier for folksonomy. //Check if it matches with the one in folksonomy jcr node if (repositoryUserFolksonomy.getId() != null) { if (!repositoryUserFolksonomy.getId().equals(folksonomyIdentifier) && !StringUtils.equals(CmsApiConstants.SYSTEM_REPOSITORY_USER_EXTRENAL_ID, repositoryUser.getExternalId())) { throw new CmsException("Folksonomy identifier " + folksonomyIdentifier + " for repository user " + repositoryUser.getLabel() + " does not match with the provided identifier " + repositoryUserFolksonomy.getId()); } } else { //User does not have an identifier for folksonomy. Update its value repositoryUserFolksonomy.setId(folksonomyIdentifier); } } } } private void populatePreferences(RepositoryUser repositoryUser, Node repositoryUserNode) { } private void populateSpace(RepositoryUser repositoryUser, Node repositoryUserNode, Session session, Context context) throws RepositoryException { Space repositoryUserSpace = repositoryUser.getSpace(); if (repositoryUserSpace == null) { ((RepositoryUserImpl) repositoryUser).setSpace(cmsRepositoryEntityFactoryForActiveClient.newSpace()); repositoryUserSpace = repositoryUser.getSpace(); } if (!repositoryUser.getSpace().hasLocalizedLabels() && MapUtils.isNotEmpty(defaultSpaceLocalization.getLocalizedLabels())) { repositoryUser.getSpace().getLocalizedLabels().putAll(defaultSpaceLocalization.getLocalizedLabels()); } if (repositoryUserSpace.getName() == null) { repositoryUserSpace.setName("spaceForUser" + repositoryUser.getExternalId()); } //Since Space name must follow a specific pattern, check if repository user space name is valid. //if not then issue a warning and replace value with a default value. if (!cmsRepositoryEntityUtils.isValidSystemName(repositoryUserSpace.getName())) { //First try to remove all white spaces, in case space name has not changed since it was first created by the //following line of code //repositoryUserSpace.setName("Space for user"+ repositoryUser.getExternalId()); String nameWithoutWhiteSpaces = StringUtils.deleteWhitespace(repositoryUserSpace.getName()); if (!cmsRepositoryEntityUtils.isValidSystemName(nameWithoutWhiteSpaces)) { //Name is still invalid. Issue a warning and replace name so that save can continue safely logger.warn( "Repository User's '{}' Space name '{}' does not follow pattern {} and to will change to 'spaceForUser'. " + " In order to provide a different name you must explicitly save RepositotyUser Space by using SpaceService.", new Object[] { repositoryUser.getLabel(), repositoryUserSpace.getName(), CmsConstants.SYSTEM_NAME_REG_EXP }); } else { repositoryUserSpace.setName(nameWithoutWhiteSpaces); } } //Create Space if it does not exist Node spaceNode = null; if (!repositoryUserNode.hasNode(CmsBuiltInItem.Space.getJcrName())) { repositoryUserSpace.setOwner(repositoryUser); repositoryUserSpace.setOrder(Long.valueOf(1)); //Create new node spaceNode = JcrNodeUtils.addSpaceNode(repositoryUserNode, CmsBuiltInItem.Space.getJcrName()); //Create a Astroboa identifier for space or use the one provided cmsRepositoryEntityUtils.createCmsIdentifier(spaceNode, repositoryUserSpace, true); //Set Owner //Inform associations about relation between new space and repository user EntityAssociationUpdateHelper<RepositoryUser> repositoryUserAssociationUpdateHelper = new EntityAssociationUpdateHelper<RepositoryUser>( session, cmsRepositoryEntityAssociationDao, context); repositoryUserAssociationUpdateHelper.setReferrerCmsRepositoryEntityNode(spaceNode); repositoryUserAssociationUpdateHelper.setReferrerPropertyName(CmsBuiltInItem.OwnerCmsIdentifier); repositoryUserAssociationUpdateHelper.setValuesToBeAdded(Arrays.asList(repositoryUser)); repositoryUserAssociationUpdateHelper.update(); } else { spaceNode = repositoryUserNode.getNode(CmsBuiltInItem.Space.getJcrName()); if (!repositoryUser.getSpace().hasLocalizedLabels() && MapUtils.isNotEmpty(defaultSpaceLocalization.getLocalizedLabels())) { repositoryUser.getSpace().getLocalizedLabels() .putAll(defaultSpaceLocalization.getLocalizedLabels()); } //Space node is not new. Check that an identifier exists if (!cmsRepositoryEntityUtils.hasCmsIdentifier(spaceNode)) { cmsRepositoryEntityUtils.createCmsIdentifier(spaceNode, repositoryUserSpace, true); } else { String spaceIdentifier = cmsRepositoryEntityUtils.getCmsIdentifier(spaceNode); //User has provided an identifier for space //Check if it matches with the one in space jcr node only if space does not represent SYSTEM's space if (repositoryUserSpace.getId() != null) { if (!repositoryUserSpace.getId().equals(spaceIdentifier) && !StringUtils.equals(CmsApiConstants.SYSTEM_REPOSITORY_USER_EXTRENAL_ID, repositoryUser.getExternalId())) { throw new CmsException("Space identifier " + spaceIdentifier + " for repository user " + repositoryUser.getLabel() + " does not match with the provided identifier " + repositoryUserSpace.getId()); } } else { //User does not have an identifier for space. Update its value repositoryUserSpace.setId(spaceIdentifier); } } } //Update localization for repository user space spaceUtils.updateLocalizedLabels(repositoryUser.getSpace(), spaceNode); //Populate Node with default values spaceUtils.updateOrder(repositoryUser.getSpace(), spaceNode); spaceUtils.updateName(repositoryUser.getSpace(), spaceNode); } private void removeReferencesForRepositoryUser(Session session, RepositoryUser alternativeUser, boolean removeObjectsWhoseOwnerIsTheUserToBeDeleted, String repositoryUserId, Context context) throws Exception { if (removeObjectsWhoseOwnerIsTheUserToBeDeleted) { removeObjectsWhoseOwnerIsTheUserToBeDeleted(session, repositoryUserId, context); } else { RepositoryUser userToBeRemoved = cmsRepositoryEntityFactoryForActiveClient.newRepositoryUser(); userToBeRemoved.setId(repositoryUserId); EntityAssociationDeleteHelper<RepositoryUser> repositoryUserRemover = new EntityAssociationDeleteHelper<RepositoryUser>( session, cmsRepositoryEntityAssociationDao, context); if (alternativeUser != null) { repositoryUserRemover.setCmsRepositoryEntityIdReplacement(alternativeUser.getId()); } repositoryUserRemover.setCmsRepositoryEntityIdToBeRemoved(userToBeRemoved.getId()); repositoryUserRemover.removeOrReplaceAllReferences(RepositoryUser.class); } } private void removeObjectsWhoseOwnerIsTheUserToBeDeleted(Session session, String repositoryUserId, Context context) throws RepositoryException { removeContentObjectsOwnedByUser(repositoryUserId, session, context); removeSpacesOwnedByUser(repositoryUserId, session, context); } private void removeContentObjectsOwnedByUser(String repositoryUserId, Session session, Context context) throws RepositoryException { ContentObjectCriteria contentObjectCriteria = CmsCriteriaFactory.newContentObjectCriteria(); contentObjectCriteria.addOwnerIdEqualsCriterion(repositoryUserId); NodeIterator contentObjectNodesFound = cmsQueryHandler .getNodesFromXPathQuery(session, contentObjectCriteria).getNodeIterator(); while (contentObjectNodesFound.hasNext()) { Node contentObjectNode = contentObjectNodesFound.nextNode(); contentObjectDao.removeContentObjectNode(contentObjectNode, true, session, context); } } private void removeSpacesOwnedByUser(String repositoryUserId, Session session, Context context) throws RepositoryException { Map<String, Node> spacesToBeDeleted = new HashMap<String, Node>(); SpaceCriteria spaceCriteria = CmsCriteriaFactory.newSpaceCriteria(); spaceCriteria.addOwnerIdEqualsCriterion(repositoryUserId); NodeIterator spacesFound = cmsQueryHandler.getNodesFromXPathQuery(session, spaceCriteria).getNodeIterator(); while (spacesFound.hasNext()) { Node spaceNode = spacesFound.nextNode(); //Organization Space is not to be deleted if (Space.ORGANIZATION_SPACE_NAME.equalsIgnoreCase(spaceNode.getName())) { throw new CmsException(Space.ORGANIZATION_SPACE_NAME + " cannot be deleted"); } Node parent = spaceNode.getParent(); if (!parent.isNodeType(CmsBuiltInItem.RepositoryUser.getJcrName()) && !spacesToBeDeleted.containsKey(spaceNode.getIdentifier())) { boolean found = false; //Iterate through space tree to see if its parent is marked for deletion while (parent != null && parent.isNodeType(CmsBuiltInItem.Space.getJcrName())) { if (!spacesToBeDeleted.containsKey(parent.getIdentifier())) { parent = parent.getParent(); } else { found = true; break; } } if (!found) { spacesToBeDeleted.put(spaceNode.getIdentifier(), spaceNode); } } } if (MapUtils.isNotEmpty(spacesToBeDeleted)) { for (Node node : spacesToBeDeleted.values()) { spaceUtils.removeSpaceJcrNode(node, session, true, context); } } } public RepositoryUser getRepositoryUser(String externalId) { if (StringUtils.isBlank(externalId)) { throw new CmsException("No external id provided"); } RepositoryUserCriteria repositoryUserCriteria = CmsCriteriaFactory.newRepositoryUserCriteria(); repositoryUserCriteria.addExternalIdEqualsCriterion(externalId); repositoryUserCriteria.setOffsetAndLimit(0, 1); List<RepositoryUser> repositoryUsers = searchRepositoryUsers(repositoryUserCriteria); if (CollectionUtils.isNotEmpty(repositoryUsers) && repositoryUsers.size() > 1) { throw new CmsException("Found more than one repository user with external id " + externalId); } return repositoryUsers.isEmpty() ? null : repositoryUsers.get(0); } }