/**
* @see org.alfresco.web.action.ActionEvaluator#evaluate(org.alfresco.web.bean.repository.Node)
*/
public boolean evaluate(Node node) {
final FacesContext fc = FacesContext.getCurrentInstance();
final ServiceRegistry services = Repository.getServiceRegistry(fc);
final NavigationBean navigator =
(NavigationBean) FacesHelper.getManagedBean(fc, NavigationBean.BEAN_NAME);
// get the path to the current name - compare last element with the Forms folder name
final Path path = navigator.getCurrentNode().getNodePath();
final Path.Element element = path.get(path.size() - 1);
final String endPath = element.getPrefixedString(services.getNamespaceService());
// check we have the permission to create nodes in that Forma folder
return (Application.getContentFormsFolderName(fc).equals(endPath)
&& navigator.getCurrentNode().hasPermission(PermissionService.ADD_CHILDREN));
}
/**
* @see org.alfresco.web.action.ActionEvaluator#evaluate(org.alfresco.web.bean.repository.Node)
*/
public boolean evaluate(final Node node) {
// is the authenticated user permitted to execute the regenerate renditions action
// against at least one web project
boolean isUserAllowed = false;
final FacesContext fc = FacesContext.getCurrentInstance();
final ServiceRegistry services = Repository.getServiceRegistry(fc);
final PermissionService permissionService = services.getPermissionService();
final WebProjectService webProjectService = services.getWebProjectService();
final NavigationBean navigator =
(NavigationBean) FacesHelper.getManagedBean(fc, NavigationBean.BEAN_NAME);
// check that the authenticated user has CONTENT MANAGER permissions for at least one web
// project
// this will ensure that the action appears only if the user is able to regenerate renditions
// for at least one web project
List<WebProjectInfo> wpInfos = webProjectService.listWebProjects();
for (WebProjectInfo wpInfo : wpInfos) {
if (permissionService.hasPermission(
wpInfo.getNodeRef(), PermissionService.WCM_CONTENT_MANAGER)
== AccessStatus.ALLOWED) {
isUserAllowed = true;
break;
}
}
// TODO improve how we determine whether the form supports the ability to regenerate renditions
// or not
// get the path to the current name - compare each path element with the Web Forms folder name
final Path path = navigator.getCurrentNode().getNodePath();
boolean isWebFormsPath = false;
Iterator<Path.Element> itr = path.iterator();
while (itr.hasNext()) {
Path.Element element = (Path.Element) itr.next();
String pathElement = element.getPrefixedString(services.getNamespaceService());
if (Application.getWebContentFormsFolderName(fc).equals(pathElement)) {
isWebFormsPath = true;
break;
}
}
return (node.hasAspect(WCMAppModel.ASPECT_RENDERING_ENGINE_TEMPLATE) || isWebFormsPath)
&& isUserAllowed;
}
/**
* Return relative path between from and to references within export root
*
* @param fromRef from reference
* @param toRef to reference
* @return path
*/
private Path createPath(NodeRef rootRef, NodeRef fromRef, NodeRef toRef) {
// Check that item exists first
if (!nodeService.exists(toRef)) {
// return null path
return null;
}
// Check whether item is the root node of the store
// If so, always return absolute path
if (toRef.equals(nodeService.getRootNode(toRef.getStoreRef()))) {
return nodeService.getPath(toRef);
}
// construct relative path
Path rootPath = createIndexedPath(rootRef, nodeService.getPath(rootRef));
Path fromPath = createIndexedPath(fromRef, nodeService.getPath(fromRef));
Path toPath = createIndexedPath(toRef, nodeService.getPath(toRef));
Path relativePath = null;
try {
// Determine if 'to path' is a category
// TODO: This needs to be resolved in a more appropriate manner - special support is
// required for categories.
for (int i = 0; i < toPath.size(); i++) {
Path.Element pathElement = toPath.get(i);
if (pathElement.getPrefixedString(namespaceService).equals("cm:categoryRoot")) {
Path.ChildAssocElement childPath = (Path.ChildAssocElement) pathElement;
relativePath = new Path();
relativePath.append(
new Path.ChildAssocElement(
new ChildAssociationRef(null, null, null, childPath.getRef().getParentRef())));
relativePath.append(toPath.subPath(i + 1, toPath.size() - 1));
break;
}
}
if (relativePath == null) {
// Determine if from node is relative to export tree
int i = 0;
while (i < rootPath.size()
&& i < fromPath.size()
&& rootPath.get(i).equals(fromPath.get(i))) {
i++;
}
if (i == rootPath.size()) {
// Determine if to node is relative to export tree
i = 0;
while (i < rootPath.size()
&& i < toPath.size()
&& rootPath.get(i).equals(toPath.get(i))) {
i++;
}
if (i == rootPath.size()) {
// build relative path between from and to
relativePath = new Path();
for (int p = 0; p < fromPath.size() - i; p++) {
relativePath.append(new Path.ParentElement());
}
if (i < toPath.size()) {
relativePath.append(toPath.subPath(i, toPath.size() - 1));
}
}
}
}
if (relativePath == null) {
// default to absolute path
relativePath = toPath;
}
} catch (Throwable e) {
String msg =
"Failed to determine relative path: root path="
+ rootPath
+ "; from path="
+ fromPath
+ "; to path="
+ toPath;
throw new ExporterException(msg, e);
}
return relativePath;
}
