/*
* Copyright (C) 2003-2009 eXo Platform SAS.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Affero General Public License
* as published by the Free Software Foundation; either version 3
* of the License, or (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see<http://www.gnu.org/licenses/>.
*/
package org.exoplatform.services.cms.link;
import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import org.exoplatform.container.ExoContainer;
import org.exoplatform.container.ExoContainerContext;
import org.exoplatform.services.wcm.utils.WCMCoreUtils;
/**
* Created by The eXo Platform SAS
* Author : eXoPlatform
* nicolas.filotto@exoplatform.com
* 1 avr. 2009
*/
public final class LinkUtils {
/**
* Convert a path of type /my/../folder or /my/./folder to a real path
* @param path the path to convert
* @return the real absolute path
*/
public static String evaluatePath(String path) {
if (!path.startsWith("/")) {
throw new IllegalArgumentException("The path '" + path + "' must be an absolute path");
}
path = cleanPath(path);
int index;
while ((index = path.indexOf("/..")) != -1) {
if (index == 0) {
path = path.substring(3);
} else {
path = createPath(getParentPath(path.substring(0, index)), path.substring(index + 3));
if (!path.endsWith("/")) path = path.concat("/");
}
}
// Avoid for file with name starts with a dot
while ((index = path.indexOf("/./")) != -1) {
if (index == 0) {
path = path.substring(2);
} else {
path = createPath(path.substring(0, index), path.substring(index + 2));
}
}
path = cleanPath(path);
return path.length() == 0 ? "/" : path;
}
/**
* Gives the name of the item according to the given absolute path
* @param path the absolute of the item
* @return the item name
*/
public static String getItemName(String path) {
if (!path.startsWith("/")) {
throw new IllegalArgumentException("The path '" + path + "' must be an absolute path");
}
path = cleanPath(path);
int index = path.lastIndexOf('/');
return path.substring(index + 1);
}
/**
* Appends the parentPath and the relativePath to give a full absolute path
*/
public static String createPath(String parentPath, String relativePath) {
if (!parentPath.startsWith("/")) {
throw new IllegalArgumentException("The path '" + parentPath + "' must be an absolute path");
}
parentPath = cleanPath(parentPath);
relativePath = cleanPath(relativePath);
if (relativePath.startsWith("/")) {
relativePath = relativePath.substring(1);
}
StringBuilder path = new StringBuilder(128);
path.append(parentPath);
if (relativePath.length() > 0) {
if (!parentPath.equals("/")) {
path.append('/');
}
path.append(relativePath);
}
return path.toString();
}
/**
* Gives the total depth of the given absolute path
* @param path an absolute path
* @return the depth of the path
*/
public static int getDepth(String path) {
if (!path.startsWith("/")) {
throw new IllegalArgumentException("The path '" + path + "' must be an absolute path");
}
path = cleanPath(path);
if (path.equals("/")) {
return 0;
}
return path.substring(1).split("/").length;
}
/**
* Gives the ancestor of the given path corresponding to the given depth knowing that:
* <ul>
* <li><i>depth</i> = 0 returns the root node.
* <li><i>depth</i> = 1 returns the child of the root node along the path
* to <i>this</i> <code>Item</code>.
* <li><i>depth</i> = 2 returns the grandchild of the root node along the
* path to <i>this</i> <code>Item</code>.
* <li>And so on to <i>depth</i> = <i>n</i>, where <i>n</i> is the depth
* of <i>this</i> <code>Item</code>, which returns <i>this</i>
* <code>Item</code> itself.
* </ul>
*/
public static String getAncestorPath(String path, int depth) {
if (!path.startsWith("/")) {
throw new IllegalArgumentException("The path '" + path + "' must be an absolute path");
}
path = cleanPath(path);
if (depth == 0) {
return "/";
}
String[] subpath = path.substring(1).split("/");
StringBuilder result = new StringBuilder(128);
for (int i = 0; i < depth; i++) {
result.append('/');
result.append(subpath[i]);
}
return result.toString();
}
/**
* Gives the parent path of the given path
* @param path an absolute path
* @return the parent path
*/
public static String getParentPath(String path) {
if (!path.startsWith("/")) {
throw new IllegalArgumentException("The path '" + path + "' must be an absolute path");
}
path = cleanPath(path);
if (path.equals("/")) {
return "/";
}
int index = path.lastIndexOf('/');
if (index == 0) {
return "/";
}
return path.substring(0, index);
}
public static NodeFinder getNodeFinder() {
ExoContainer context = ExoContainerContext.getCurrentContainer();
return (NodeFinder) context.getComponentInstance(NodeFinder.class);
}
public static LinkManager getLinkManager() {
return WCMCoreUtils.getService(LinkManager.class);
}
/**
* The procedure which return the path existed in tree.
*
* @param node is a Node type which represents current node.
* @param path a current path
* @return the path existed in tree
* @throws RepositoryException when some exceptions occurrence.
*/
public static String getExistPath(Node node, String path) throws RepositoryException {
// The following process is added by lampt.
int deep = getDepth(path);
// In case of path is root path.
if (deep == 0) {
path = LinkUtils.getAncestorPath(path, 0);
} else {
Session session = node.getSession();
for (int i = deep; i > 0; i-- ) {
if (session.itemExists(path))
break;
path = getParentPath(path);
}
}
return path;
}
private static String cleanPath(String path) {
// Remove unnecessary '/'
path = path.replaceAll("/+", "/");
// Avoid for file with name starts with a dot
if ((!(path.contains("/./"))) && path.length() > 1 && path.charAt(path.length() - 1) == '/') {
path = path.substring(0, path.length() - 1);
}
return path;
}
}