Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2009 eXo Platform SAS.
   *
   * This 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 2.1 of
   * the License, or (at your option) any later version.
   *
   * This software 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 this software; if not, write to the Free
  * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
  */
 package org.exoplatform.services.jcr.ext.hierarchy.impl;
 
 import  org.picocontainer.Startable;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 import javax.jcr.Node;
Created by The eXo Platform SAS Author : Dang Van Minh minh.dang@exoplatform.com Nov 15, 2007 2:21:57 PM
 
 public class NodeHierarchyCreatorImpl implements NodeHierarchyCreator, Startable
 {
 
    private static final Log LOG = ExoLogger.getLogger("exo.jcr.component.ext.NodeHierarchyCreatorImpl");
 
    private static final String USERS_PATH = "usersPath";
 
    private static final String USER_APPLICATION = "userApplicationData";
 
    private static final String PUBLIC_APPLICATION = "eXoApplications";
 
    private static final String USER_PRIVATE = "userPrivate";
 
    private static final String USER_PUBLIC = "userPublic";
 
    private final RepositoryService jcrService_;
 
 
    private final List<AddPathPluginpathPlugins_ = new ArrayList<AddPathPlugin>();
 
    private final Map<StringStringpaths_ = new HashMap<StringString>();
 
    private final boolean oldDistribution;
 
    private final boolean autoMigrate;
 
    public NodeHierarchyCreatorImpl(RepositoryService jcrServiceInitParams params)
    {
       this(jcrServicenullparams);
    }
 
    public NodeHierarchyCreatorImpl(RepositoryService jcrServiceDataDistributionManager dataDistributionManager,
       InitParams params)
    {
       if (dataDistributionManager == null)
       {
          throw new IllegalArgumentException("The DataDistributionManager is now mandatory if you use the "
             + "NodeHierarchyCreator, so please define it in your configuration "
             + "as described in the JCR documentation");
       }
        = jcrService;
        = dataDistributionManager;
        =
          params != null && params.getValueParam("old-user-distribution") != null
             && Boolean.valueOf(params.getValueParam("old-user-distribution").getValue());
        =
         params != null && params.getValueParam("auto-migrate") != null
            && Boolean.valueOf(params.getValueParam("auto-migrate").getValue());
      
      if (PropertyManager.isDevelopping() && !)
      {
         .info("The NodeHierarchyCreator is configured to use the new distribution mechanism for the"
            + " users directories, if you prefer to use the old mechanism set the value parameter "
            + "'old-user-distribution' to 'true'.");
      }
   }

   
   public void start()
   {
      try
      {
         processAddPathPlugin();
      }
      catch (Exception e)
      {
         .error("An error occurs while processing the plugins"e);
      }
      if (isNeededToMigrate())
      {
         try
         {
            migrate();
         }
         catch (RepositoryException e)
         {
            .error("An error occurs while upgrading JCR structure"e);
         }
      }
   }

   
   public void stop()
   {
   }

   
   public void init(String repositorythrows Exception
   {
      initBasePath(repository);
   }

   
   public void init() throws Exception
   {
      initBasePath(null);
   }
   private void createNode(Node rootNodeString pathString nodeTypeList<StringmixinTypes,
      Map<StringString[]> permissionsthrows Exception
   {
         nodeTypemixinTypespermissions);
   }
   private void processAddPathPlugin() throws Exception
   {
      Session session = null;
      for (AddPathPlugin pathPlugin : )
      {
         HierarchyConfig hierarchyConfig = pathPlugin.getPaths();
         if (hierarchyConfig == null)
         {
            continue;
         }         
         List<JcrPathjcrPaths = hierarchyConfig.getJcrPaths();
         if (jcrPaths == null)
         {
            continue;
         }
         Set<StringworkspaceNames = new LinkedHashSet<String>();
         if (hierarchyConfig.getWorkspaces() != null)
         {
            workspaceNames.addAll(hierarchyConfig.getWorkspaces());
         }
         String repositoryName = hierarchyConfig.getRepository();
         ManageableRepository repository = repositoryName == null || repositoryName.isEmpty() ? 
               .getCurrentRepository() : 
               .getRepository(repositoryName);
         
         for (String workspaceName : workspaceNames)
         {
            JcrPath currentjcrPath = null;
            try
            {
               session = repository.getSystemSession(workspaceName);
               Node rootNode = session.getRootNode();
               for (JcrPath jcrPath : jcrPaths)
               {
                  currentjcrPath = jcrPath;
                  if (!jcrPath.getAlias().equals() && !jcrPath.getAlias().startsWith()
                     && !jcrPath.getAlias().startsWith())
                  {
                     createNode(rootNodejcrPath.getPath(), jcrPath.getNodeType(), jcrPath.getMixinTypes(),
                        jcrPath.getPermissions(null));
                  }
               }
            }
            catch (RepositoryException e)
            {
               .error("An error occurs while processing the JCR path which alias is "
                  + (currentjcrPath == null ? null : currentjcrPath.getAlias()) + " with the workspace "
                  + workspaceNamee);
            }
            finally
            {
               if (session != null)
               {
                  session.logout();
                  session = null;
               }
            }
         }
      }
   }
   private void initBasePath(String repositoryNamethrows Exception
   {
      Session session = null;
      ManageableRepository manageableRepository =
         repositoryName == null || repositoryName.isEmpty() ? .getCurrentRepository() : 
            .getRepository(repositoryName);
      String defaultWorkspace = manageableRepository.getConfiguration().getDefaultWorkspaceName();
      String systemWorkspace = manageableRepository.getConfiguration().getSystemWorkspaceName();
      boolean isSameWorkspace = defaultWorkspace.equalsIgnoreCase(systemWorkspace);
      String[] workspaceNames = manageableRepository.getWorkspaceNames();
      for (AddPathPlugin pathPlugin : )
      {
         HierarchyConfig hierarchyConfig = pathPlugin.getPaths();
         if (hierarchyConfig == null)
         {
            continue;
         }
         List<JcrPathjcrPaths = hierarchyConfig.getJcrPaths();
         if (jcrPaths == null)
         {
            continue;
         }
         for (String workspaceName : workspaceNames)
         {
            if (!isSameWorkspace && workspaceName.equalsIgnoreCase(systemWorkspace))
               continue;
            JcrPath currentjcrPath = null;
            try
            {
               session = manageableRepository.getSystemSession(workspaceName);
               Node rootNode = session.getRootNode();
               for (JcrPath jcrPath : jcrPaths)
               {
                  currentjcrPath = jcrPath;
                  if (!jcrPath.getAlias().equals() && !jcrPath.getAlias().startsWith()
                     && !jcrPath.getAlias().startsWith())
                  {
                     createNode(rootNodejcrPath.getPath(), jcrPath.getNodeType(), jcrPath.getMixinTypes(),
                        jcrPath.getPermissions(null));
                  }
               }
            }
            catch (Exception e)
            {
               .error("An error occurs while processing the JCR path which alias is "
                  + (currentjcrPath == null ? null : currentjcrPath.getAlias()) + " with the workspace "
                  + workspaceNamee);
            }
            finally
            {
               if (session != null)
               {
                  session.logout();
                  session = null;
               }
            }
         }
      }
   }

   
   public Node getUserApplicationNode(SessionProvider sessionProviderString userNamethrows Exception
   {
      Node userNode = getUserNode(sessionProvideruserName);
         getJcrPath());
   }

   
   public Node getPublicApplicationNode(SessionProvider sessionProviderthrows Exception
   {
      Session session = getSession(sessionProvider);
      Node rootNode = session.getRootNode();
         getJcrPath());
   }

   
   public Node getUserNode(SessionProvider sessionProviderString userNamethrows Exception
   {
      Session session = getSession(sessionProvider);
      Node usersNode = getRootOfUsersNodes(session);
      DataDistributionType type =
            : .);
      return type.getOrCreateDataNode(usersNodeuserName);
   }

   
   public void removeUserNode(SessionProvider sessionProviderString userNamethrows Exception
   {
      Session session = getSession(sessionProvider);
      try
      {
         Node usersNode = getRootOfUsersNodes(session);
         DataDistributionType type =
               : .);
         type.removeDataNode(usersNodeuserName);
      }
      catch (PathNotFoundException e)
      {
         if (.isTraceEnabled())
         {
            .trace("An exception occurred: " + e.getMessage());
         }
      }
   }
   private Session getSession(SessionProvider sessionProviderthrows RepositoryException
   {
      return sessionProvider.getSession(repo.getConfiguration().getDefaultWorkspaceName(), repo);
   }

   
   public String getJcrPath(String alias)
   {
      return .get(alias);
   }

   
   public void addPlugin(ComponentPlugin plugin)
   {
      if (plugin instanceof AddPathPlugin)
      {
         AddPathPlugin app = (AddPathPlugin)plugin;
         .add(app);
         if (app.getPaths() != null && app.getPaths().getJcrPaths() != null)
         {
            for (JcrPath jcrPath : app.getPaths().getJcrPaths())
            {
               if (jcrPath.getAlias() != null && jcrPath.getPath() != null)
               {
                  .put(jcrPath.getAlias(), jcrPath.getPath());
               }
            }
         }
      }
   }
   private boolean isNeededToMigrate()
   {
      return ! && ;
   }
   private void migrate() throws RepositoryException
   {
      Session session = getSession(SessionProvider.createSystemProvider());
      try
      {
         Node rootNode = getRootOfUsersNodes(session);
      }
      finally
      {
         session.logout();
      }
   }
   {
      String usersPath = getJcrPath();
      return (Node)session.getItem(usersPath);
   }
New to GrepCode? Check out our FAQ X