| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.sling.ide.eclipse.ui.nav.model; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.StringTokenizer; |
| |
| import javax.jcr.PropertyType; |
| import javax.jcr.nodetype.NodeType; |
| import javax.jcr.nodetype.PropertyDefinition; |
| import javax.xml.parsers.ParserConfigurationException; |
| |
| import org.apache.jackrabbit.util.ISO9075; |
| import org.apache.sling.ide.eclipse.core.ProjectUtil; |
| import org.apache.sling.ide.eclipse.core.ServerUtil; |
| import org.apache.sling.ide.eclipse.core.internal.Activator; |
| import org.apache.sling.ide.eclipse.ui.WhitelabelSupport; |
| import org.apache.sling.ide.eclipse.ui.views.PropertyTypeSupport; |
| import org.apache.sling.ide.filter.Filter; |
| import org.apache.sling.ide.filter.FilterResult; |
| import org.apache.sling.ide.log.Logger; |
| import org.apache.sling.ide.serialization.SerializationKind; |
| import org.apache.sling.ide.serialization.SerializationKindManager; |
| import org.apache.sling.ide.serialization.SerializationManager; |
| import org.apache.sling.ide.transport.NodeTypeRegistry; |
| import org.apache.sling.ide.transport.Repository; |
| import org.apache.sling.ide.transport.RepositoryException; |
| import org.apache.sling.ide.transport.ResourceProxy; |
| import org.eclipse.core.resources.IContainer; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IWorkspaceRunnable; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.resources.mapping.ResourceMapping; |
| import org.eclipse.core.resources.mapping.ResourceMappingContext; |
| import org.eclipse.core.resources.mapping.ResourceTraversal; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.swt.dnd.Clipboard; |
| import org.eclipse.swt.dnd.DND; |
| import org.eclipse.swt.dnd.FileTransfer; |
| import org.eclipse.swt.dnd.TextTransfer; |
| import org.eclipse.swt.dnd.Transfer; |
| import org.eclipse.swt.dnd.TransferData; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.ui.IActionFilter; |
| import org.eclipse.ui.IContributorResourceAdapter; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.actions.CopyFilesAndFoldersOperation; |
| import org.eclipse.ui.model.WorkbenchLabelProvider; |
| import org.eclipse.ui.part.ResourceTransfer; |
| import org.eclipse.ui.views.properties.IPropertySource; |
| import org.eclipse.ui.views.properties.tabbed.ITabbedPropertySheetPageContributor; |
| import org.xml.sax.SAXException; |
| |
| import de.pdark.decentxml.Attribute; |
| import de.pdark.decentxml.Document; |
| import de.pdark.decentxml.Element; |
| import de.pdark.decentxml.Namespace; |
| import de.pdark.decentxml.Node; |
| import de.pdark.decentxml.Text; |
| import de.pdark.decentxml.XMLParseException; |
| import de.pdark.decentxml.XMLTokenizer.Type; |
| |
| /** WIP: model object for a jcr node shown in the content package view in project explorer **/ |
| public class JcrNode implements IAdaptable { |
| |
| private final static WorkbenchLabelProvider workbenchLabelProvider = new WorkbenchLabelProvider(); |
| |
| final GenericJcrRootFile underlying; |
| |
| JcrNode parent; |
| |
| DirNode dirSibling; |
| |
| final List<JcrNode> children = new LinkedList<>(); |
| |
| Element domElement; |
| |
| private IResource resource; |
| |
| private boolean resourceChildrenAdded = false; |
| |
| final ModifiableProperties properties = new ModifiableProperties(this); |
| |
| final Set<JcrNode> hiddenChildren = new HashSet<>(); |
| |
| JcrNode() { |
| // for subclass use only |
| if (this instanceof GenericJcrRootFile) { |
| this.underlying = (GenericJcrRootFile) this; |
| } else { |
| this.underlying = null; |
| } |
| } |
| |
| JcrNode(JcrNode parent, Element domElement, IResource resource) { |
| this(parent, domElement, parent.underlying, resource); |
| } |
| |
| |
| JcrNode(JcrNode parent, Element domElement, GenericJcrRootFile underlying, IResource resource) { |
| if (parent == null) { |
| throw new IllegalArgumentException("parent must not be null"); |
| } |
| this.parent = parent; |
| // domElement can be null |
| this.domElement = domElement; |
| this.underlying = underlying; |
| this.resource = resource; |
| parent.addChild(this); |
| } |
| |
| @Override |
| public String toString() { |
| return getClass().getSimpleName() + "[dom:"+domElement+", file:"+resource+", jcrPath:"+getJcrPath()+"]"; |
| } |
| |
| @Override |
| public int hashCode() { |
| if (underlying==null) { |
| if (resource==null) { |
| if (domElement==null) { |
| return toString().hashCode(); |
| } else { |
| Element domElementCopy = domElement.copy(); |
| domElementCopy.clearChildren(); |
| return domElementCopy.toString().hashCode() + parent.hashCode(); |
| } |
| } else { |
| return resource.getFullPath().hashCode(); |
| } |
| } else { |
| if (domElement==null) { |
| return underlying.hashCode(); |
| } |
| Element domElementCopy = domElement.copy(); |
| domElementCopy.clearChildren(); |
| return underlying.hashCode() + domElementCopy.toString().hashCode(); |
| } |
| } |
| |
| @Override |
| public boolean equals(Object obj) { |
| if (this==obj) { |
| return true; |
| } |
| if (!(obj instanceof JcrNode)) { |
| return false; |
| } |
| JcrNode other = (JcrNode) obj; |
| if (resource!=null && other.resource!=null) { |
| if (resource.equals(other.resource)) { |
| return true; |
| } else { |
| return false; |
| } |
| } else if (resource!=null && other.resource==null) { |
| return false; |
| } else if (resource==null && other.resource!=null) { |
| return false; |
| } |
| if (other.underlying==null && underlying!=null) { |
| return false; |
| } else if (other.underlying!=null && underlying==null) { |
| return false; |
| } |
| if (underlying!=null && !underlying.equals(other.underlying)) { |
| return false; |
| } |
| if (parent!=null && other.parent!=null) { |
| if (!parent.equals(other.parent)) { |
| return false; |
| } |
| Element domElementCopy = domElement.copy(); |
| domElementCopy.clearChildren(); |
| Element otherDomElementCopy = other.domElement.copy(); |
| otherDomElementCopy.clearChildren(); |
| return domElementCopy.toString().equals(otherDomElementCopy.toString()); |
| } |
| return toString().equals(obj.toString()); |
| } |
| |
| protected void addChild(JcrNode jcrNode) { |
| if (!children.contains(jcrNode)) { |
| // check to see if there is a same-named node though |
| // that is the dom/resource case |
| for (JcrNode existingChild : children) { |
| if (existingChild.getName().equals(jcrNode.getName())) { |
| // then merge the two |
| existingChild.setResource(jcrNode.resource); |
| return; |
| } |
| } |
| children.add(jcrNode); |
| } |
| } |
| |
| /** shown in the navigator (project explorer) as the label of this element **/ |
| public String getLabel() { |
| if (domElement!=null && resource!=null) { |
| return ISO9075.decode(getDomName());// + "[domnode+file]"; |
| } else if (domElement!=null && resource==null) { |
| return ISO9075.decode(getDomName());// + "[domnode]"; |
| } else if (resource!=null) { |
| return resource.getName();//+" [file]"; |
| } else { |
| return "n/a"; |
| } |
| } |
| |
| /** shown in the statusbar when this element is selected **/ |
| public String getDescription() { |
| return getJcrPath(); |
| } |
| |
| public boolean hasChildren() { |
| boolean members; |
| try { |
| members = resource!=null && resource instanceof IFolder && ((IFolder)resource).members().length>0; |
| } catch (CoreException e) { |
| members = false; |
| } |
| return children.size()>0 || members; |
| } |
| |
| public void hide(JcrNode node) { |
| hiddenChildren.add(node); |
| } |
| |
| Object[] filterHiddenChildren(final Collection<JcrNode> collection, boolean hideEmptyNodes) { |
| final Collection<JcrNode> values = new LinkedList<>(collection); |
| |
| for (JcrNode hiddenNode : hiddenChildren) { |
| values.remove(hiddenNode); |
| } |
| if (hideEmptyNodes) { |
| for (Iterator<JcrNode> it = values.iterator(); it.hasNext();) { |
| JcrNode jcrNode = it.next(); |
| if (jcrNode.isEmptyNode()) { |
| it.remove(); |
| } |
| } |
| } |
| for (Iterator<JcrNode> it = values.iterator(); it.hasNext();) { |
| JcrNode jcrNode = it.next(); |
| if (jcrNode instanceof DirNode) { |
| DirNode dirNode = (DirNode)jcrNode; |
| // DirNodes are candidates for hiding |
| JcrNode effectiveSibling = dirNode.getEffectiveSibling(); |
| if (effectiveSibling!=null) { |
| it.remove(); |
| continue; |
| } |
| } |
| } |
| |
| return values.toArray(); |
| } |
| |
| private boolean isEmptyNode() { |
| if (resource!=null) { |
| return false; |
| } |
| if (children.size()!=0) { |
| return false; |
| } |
| if (domElement==null) { |
| return true; |
| } |
| if (domElement.hasChildren()) { |
| return false; |
| } |
| if (domElement.getAttributes().size()!=0) { |
| return false; |
| } |
| return true; |
| } |
| |
| public Object[] getChildren(boolean hideEmptyNodes) { |
| if (!resourceChildrenAdded) { |
| initChildren(); |
| } |
| return filterHiddenChildren(children, true); |
| } |
| |
| void initChildren() { |
| try { |
| if (resourceChildrenAdded) { |
| throw new IllegalStateException("Children already loaded"); |
| } |
| Set<String> childrenNames = new HashSet<>(); |
| for (Iterator<JcrNode> it = children.iterator(); it.hasNext();) { |
| JcrNode node = it.next(); |
| childrenNames.add(node.getName()); |
| } |
| |
| if (resource!=null && resource instanceof IFolder) { |
| IFolder folder = (IFolder)resource; |
| IResource[] members = folder.members(); |
| List<IResource> membersList = new LinkedList<>(Arrays.asList(members)); |
| outerLoop: while(membersList.size()>0) { |
| for (Iterator<IResource> it = membersList.iterator(); it.hasNext();) { |
| IResource iResource = it.next(); |
| if (isDotVltFile(iResource)) { |
| it.remove(); |
| continue; |
| } |
| |
| if (childShouldNotBeShown(iResource)) { |
| it.remove(); |
| continue; |
| } |
| |
| if (isVaultFile(iResource)) { |
| GenericJcrRootFile gjrf; |
| try { |
| gjrf = new GenericJcrRootFile(this, (IFile)iResource); |
| it.remove(); |
| // gjrf.getChildren(); |
| gjrf.pickResources(membersList); |
| } catch (XMLParseException e) { |
| // don't try to parse it |
| // errors will be reported by the XML validation infrastructure |
| it.remove(); |
| } |
| |
| // as this might have added some new children, go through the children again and |
| // add them if they're not already added |
| for (JcrNode node : children) { |
| if (!childrenNames.contains(node.getName())) { |
| childrenNames.add(node.getName()); |
| } |
| } |
| |
| continue outerLoop; |
| } |
| } |
| List<JcrNode> newNodes = new LinkedList<>(); |
| for (Iterator<IResource> it = membersList.iterator(); it.hasNext();) { |
| IResource iResource = (IResource) it.next(); |
| JcrNode node; |
| if (DirNode.isDirNode(iResource)) { |
| node = new DirNode(this, (Element)null, iResource); |
| } else { |
| node = new JcrNode(this, (Element)null, iResource); |
| } |
| childrenNames.add(node.getName()); |
| newNodes.add(node); |
| it.remove(); |
| } |
| } |
| } |
| resourceChildrenAdded = true; |
| } catch (CoreException e) { |
| e.printStackTrace(); |
| org.apache.sling.ide.eclipse.ui.internal.Activator.getDefault().getPluginLogger().error("Error initializing children: "+e, e); |
| } catch (ParserConfigurationException e) { |
| e.printStackTrace(); |
| org.apache.sling.ide.eclipse.ui.internal.Activator.getDefault().getPluginLogger().error("Error initializing children: "+e, e); |
| } catch (SAXException e) { |
| e.printStackTrace(); |
| org.apache.sling.ide.eclipse.ui.internal.Activator.getDefault().getPluginLogger().error("Error initializing children: "+e, e); |
| } catch (IOException e) { |
| e.printStackTrace(); |
| org.apache.sling.ide.eclipse.ui.internal.Activator.getDefault().getPluginLogger().error("Error initializing children: "+e, e); |
| } |
| } |
| |
| private boolean isDotVltFile(IResource res) { |
| return res.getType() == IResource.FILE && res.getName().equals(".vlt"); |
| } |
| |
| private boolean isVaultFile(IResource iResource) { |
| |
| return Activator.getDefault().getSerializationManager() |
| .isSerializationFile(iResource.getLocation().toOSString()); |
| } |
| |
| protected boolean childShouldNotBeShown(IResource resource) { |
| return false; |
| } |
| |
| public void setResource(IResource resource) { |
| if (this.resource!=null) { |
| if (resource.equals(this.resource)) { |
| return; |
| } |
| throw new IllegalStateException("can only set resource once"); |
| } |
| this.resource = resource; |
| } |
| |
| public Image getImage() { |
| boolean plainFolder = resource!=null && (resource instanceof IFolder); |
| String primaryType = getProperty("jcr:primaryType").getValueAsString(); |
| boolean typeFolder = probablyFolderType(primaryType); |
| boolean typeFile = primaryType!=null && ((primaryType.equals("nt:file") || primaryType.equals("nt:resource") || primaryType.equals("sling:File"))); |
| typeFile |= (resource!=null && primaryType==null); |
| boolean typeUnstructured = primaryType!=null && ((primaryType.equals("nt:unstructured"))); |
| |
| boolean isVaultFile = resource != null && isVaultFile(resource); |
| |
| String mimeType = null; |
| mimeType = getJcrContentProperty("jcr:mimeType"); |
| if (mimeType == null) { |
| mimeType = getProperty("jcr:mimeType").getValueAsString(); |
| } |
| |
| if (typeUnstructured) { |
| return WhitelabelSupport.getJcrNodeIcon().createImage(); |
| } else if (plainFolder || typeFolder) { |
| return workbenchLabelProvider.getImage(ProjectUtil.getSyncDirectory(getProject())); |
| } else if (typeFile && resource!=null) { |
| if (mimeType!=null && mimeType.length()!=0) { |
| ImageDescriptor desc = getImageDescriptor(resource.getName(), mimeType); |
| if (desc!=null) { |
| return desc.createImage(); |
| } |
| } |
| if (isVaultFile) { |
| return WhitelabelSupport.getJcrNodeIcon().createImage(); |
| } |
| return workbenchLabelProvider.getImage(resource); |
| } else { |
| if (resource!=null && !isVaultFile) { |
| return workbenchLabelProvider.getImage(resource); |
| } |
| return WhitelabelSupport.getJcrNodeIcon().createImage(); |
| } |
| |
| } |
| |
| private boolean probablyFolderType(String primaryType) { |
| return primaryType != null && |
| (primaryType.equals("nt:folder") || primaryType.equals("sling:Folder")); |
| } |
| |
| private ImageDescriptor getImageDescriptor(String filename, String jcrMimeType) { |
| final String modifiedFilename; |
| if (jcrMimeType.equals("image/jpeg")) { |
| modifiedFilename = filename + ".jpg"; |
| } else if (jcrMimeType.contains("/")) { |
| modifiedFilename = filename + "." + (jcrMimeType.substring(jcrMimeType.indexOf("/")+1)); |
| } else { |
| return null; |
| } |
| return PlatformUI.getWorkbench().getEditorRegistry().getImageDescriptor(modifiedFilename, null); |
| } |
| |
| private String getJcrContentProperty(String propertyKey) { |
| for (Object element : getChildren(false)) { |
| JcrNode jcrNode = (JcrNode) element; |
| if ("jcr:content".equals(jcrNode.getName())) { |
| return jcrNode.getProperty(propertyKey).getValueAsString(); |
| } |
| } |
| return null; |
| } |
| |
| private String getPropertyAsString(String propertyKey) { |
| if (properties!=null) { |
| Object propertyValue = properties.getValue(propertyKey); |
| if (propertyValue!=null) { |
| return String.valueOf(propertyValue); |
| } |
| } |
| return null; |
| } |
| |
| public String getName() { |
| if (domElement!=null) { |
| return ISO9075.decode(getDomName()); |
| } else if (resource!=null) { |
| return resource.getName(); |
| } else { |
| return ""; |
| } |
| } |
| |
| private String getDomName() { |
| String domName = domElement.getName(); |
| Namespace ns = domElement.getNamespace(); |
| if (ns!=null) { |
| String prefix = ns.getPrefix(); |
| if (!prefix.isEmpty()) { |
| domName = prefix + ":" + domName; |
| } |
| } |
| return domName; |
| } |
| |
| public String getJcrPath() { |
| String prefix; |
| if (parent==null) { |
| prefix = ""; |
| } else { |
| prefix = parent.getJcrPath(); |
| if (!prefix.endsWith("/")) { |
| prefix = prefix + "/"; |
| } |
| } |
| return prefix + getJcrPathName(); |
| } |
| |
| String getJcrPathName() { |
| if (domElement!=null) { |
| return ISO9075.decode(getDomName()); |
| } else if (resource!=null) { |
| if (underlying!=null && resource==underlying.getResource()) { |
| // nodename.xml |
| IResource res = underlying.getResource(); |
| String fullname = res.getName(); |
| if (fullname.endsWith(".xml")) { |
| return fullname.substring(0, fullname.length()-4); |
| } else { |
| return res.getName(); |
| } |
| } else { |
| return resource.getName(); |
| } |
| } else { |
| return ""; |
| } |
| } |
| |
| @Override |
| public Object getAdapter(Class adapter) { |
| return doGetAdapter(adapter); |
| } |
| |
| private Object doGetAdapter(Class adapter) { |
| if (adapter==ITabbedPropertySheetPageContributor.class) { |
| return new ITabbedPropertySheetPageContributor() { |
| |
| @Override |
| public String getContributorId() { |
| return "org.eclipse.ui.navigator.ProjectExplorer"; |
| } |
| |
| }; |
| } else if (adapter==IPropertySource.class) { |
| return null;//properties; |
| } else if (adapter == IFile.class) { |
| if (resource instanceof IFile) { |
| return (IFile)resource; |
| } else { |
| return null; |
| } |
| } else if ( adapter == IFolder.class) { |
| if ( resource instanceof IFolder ) { |
| return (IFolder) resource; |
| } else { |
| return null; |
| } |
| } else if (adapter == IContributorResourceAdapter.class) { |
| //if (resource==null) { |
| // return null; |
| //} |
| return new IContributorResourceAdapter() { |
| |
| @Override |
| public IResource getAdaptedResource(IAdaptable adaptable) { |
| if (!(adaptable instanceof JcrNode)) { |
| return null; |
| } |
| JcrNode node = (JcrNode)adaptable; |
| if (node.resource!=null) { |
| return node.resource; |
| } else { |
| return node.underlying.file; |
| } |
| // return null; |
| } |
| }; |
| } else if (adapter == IResource.class) { |
| if (resource!=null) { |
| return resource; |
| } else { |
| return null;//underlying.file; |
| } |
| } else if (adapter == ResourceMapping.class) { |
| boolean t = true; |
| if (!t) { |
| return null; |
| } |
| // if (resource==null) { |
| // return null; |
| // } |
| return new ResourceMapping() { |
| |
| @Override |
| public ResourceTraversal[] getTraversals(ResourceMappingContext context, |
| IProgressMonitor monitor) throws CoreException { |
| if (resource!=null) { |
| return new ResourceTraversal[] { new ResourceTraversal(new IResource[] { resource }, IResource.DEPTH_INFINITE, IResource.NONE) }; |
| } else { |
| return new ResourceTraversal[] { new ResourceTraversal(new IResource[] { underlying.file }, IResource.DEPTH_INFINITE, IResource.NONE) }; |
| } |
| } |
| |
| @Override |
| public IProject[] getProjects() { |
| if (resource!=null) { |
| return new IProject[] {resource.getProject()}; |
| } else { |
| return new IProject[] {underlying.file.getProject()}; |
| } |
| // return null; |
| } |
| |
| @Override |
| public String getModelProviderId() { |
| return "org.apache.sling.ide.eclipse.ui.nav.model.JcrNode.ResourceMapping"; |
| } |
| |
| @Override |
| public Object getModelObject() { |
| if (resource!=null) { |
| return resource; |
| } else { |
| return underlying.file; |
| } |
| } |
| }; |
| } |
| return null; |
| } |
| |
| public ModifiableProperties getProperties() { |
| return properties; |
| } |
| |
| protected boolean isBrowsable() { |
| return true; |
| } |
| |
| public IFile getFileForEditor() { |
| if ("nt:folder".equals(getPrimaryType())) { |
| // nt:folder doesn't have an underlying file for editor |
| return null; |
| } |
| |
| if (resource instanceof IFile) { |
| return (IFile)resource; |
| } |
| |
| if (properties!=null && properties.getUnderlying()!=null && properties.getUnderlying().file!=null) { |
| return properties.getUnderlying().file; |
| } |
| |
| if (underlying!=null && underlying.file!=null) { |
| return underlying.file; |
| } |
| |
| org.apache.sling.ide.eclipse.ui.internal.Activator.getDefault().getPluginLogger().warn("No file found for editor for node="+this); |
| return null; |
| } |
| |
| public IResource getResourceForImportExport() { |
| String path = getJcrPath(); |
| StringTokenizer st = new StringTokenizer(path, "/"); |
| JcrNode root = getParent(); |
| while(true) { |
| JcrNode thisParent = root.getParent(); |
| if (thisParent==null) { |
| break; |
| } |
| root = thisParent; |
| } |
| if (!(root instanceof SyncDir)) { |
| return null; |
| } |
| IFolder folder = ((SyncDir)root).getFolder(); |
| while(st.hasMoreTokens()) { |
| String nodeStr = st.nextToken(); |
| IResource child = folder.findMember(nodeStr); |
| if (child==null || !(child instanceof IFolder)) { |
| break; |
| } else { |
| folder = (IFolder) child; |
| } |
| } |
| return folder; |
| } |
| |
| public void rename(final String string) { |
| if (domElement!=null && underlying!=null) { |
| domElement.setName(string); |
| underlying.save(); |
| } |
| if (resource!=null) { |
| IWorkspaceRunnable r = new IWorkspaceRunnable() { |
| |
| @Override |
| public void run(IProgressMonitor monitor) throws CoreException { |
| final IPath fileRenamePath = resource.getParent().getFullPath().append(string); |
| resource.move(fileRenamePath, true, monitor); |
| if (dirSibling!=null) { |
| final IPath dirRenamePath = dirSibling.getResource().getParent().getFullPath().append(string+".dir"); |
| dirSibling.getResource().move(dirRenamePath, true, monitor); |
| } |
| } |
| }; |
| try { |
| ResourcesPlugin.getWorkspace().run(r, null); |
| } catch (CoreException e) { |
| Activator.getDefault().getPluginLogger().error("Error renaming resource ("+resource+"): "+e, e); |
| } |
| } |
| } |
| |
| public boolean canBeRenamed() { |
| if (parent==null) { |
| return false; |
| } |
| if (resource!=null) { |
| // can be a file or a folder (project is virtually impossible) |
| return true; |
| } |
| if (domElement!=null && underlying!=null) { |
| return true; |
| } |
| return false; |
| } |
| |
| public JcrNode getParent() { |
| return parent; |
| } |
| |
| JcrNode getChild(String name) { |
| for (JcrNode child : children) { |
| if (child.getName().equals(name)) { |
| return child; |
| } |
| } |
| return null; |
| } |
| |
| public IResource getResource() { |
| return resource; |
| } |
| |
| private SerializationKind getSerializationKind(String nodeType) { |
| final SerializationKindManager skm = new SerializationKindManager(); |
| final Repository repo = ServerUtil.getDefaultRepository(getProject()); |
| if (repo==null) { |
| return getFallbackSerializationKind(nodeType); |
| } |
| try { |
| skm.init(repo); |
| //TODO: mixins not yet supported |
| return skm.getSerializationKind(nodeType, new ArrayList<String>()); |
| } catch (RepositoryException e) { |
| e.printStackTrace(); |
| return getFallbackSerializationKind(nodeType); |
| } |
| } |
| |
| public void createChild(final String childNodeName, final String childNodeType) { |
| String thisNodeType = getPrimaryType(); |
| final SerializationKind parentSk = getSerializationKind(thisNodeType); |
| final SerializationKind childSk = getSerializationKind(childNodeType); |
| |
| final SerializationManager serializationManager = Activator.getDefault().getSerializationManager(); |
| |
| if (parentSk==SerializationKind.METADATA_FULL) { |
| createDomChild(childNodeName, childNodeType); |
| } else if (parentSk==SerializationKind.FILE) { |
| throw new IllegalStateException("cannot create child of nt:file"); |
| } else if (childSk==SerializationKind.FOLDER) { |
| IWorkspaceRunnable r = new IWorkspaceRunnable() { |
| |
| @Override |
| public void run(IProgressMonitor monitor) throws CoreException { |
| IFolder newFolder = prepareCreateFolderChild(childNodeName); |
| if (parentSk==SerializationKind.METADATA_PARTIAL) { |
| // when the parent is partial and we're creating a folder here, |
| // then we're running into a SLING-3639 type of problem |
| // the way around this is to make a 'pointer' in the 'root' |
| // .content.xml, and have a directory structure leaving to |
| // the new node, together with a .content.xml describing |
| // the type (unless it's a nt:folder that is) |
| |
| // 1) 'pointer' in the 'root .content.xml' |
| createDomChild(childNodeName, null); |
| |
| // 2) directory structure is created above already |
| // 3) new .content.xml is done below |
| } |
| if (!childNodeType.equals("nt:folder")) { |
| createVaultFile(newFolder, ".content.xml", childNodeType); |
| } |
| } |
| }; |
| |
| try { |
| ResourcesPlugin.getWorkspace().run(r, null); |
| if (childNodeType.equals("nt:folder") && parentSk==SerializationKind.FOLDER) { |
| // trigger a publish, as folder creation is not propagated to |
| // the SlingLaunchpadBehavior otherwise |
| //TODO: make configurable? Fix in Eclipse/WST? |
| ServerUtil.triggerIncrementalBuild((IFolder)resource, null); |
| } |
| } catch (CoreException e) { |
| Activator.getDefault().getPluginLogger().error("Error creating child "+childNodeName+": "+e, e); |
| e.printStackTrace(); |
| MessageDialog.openError(Display.getDefault().getActiveShell(), "Error creating node", "Error creating child of "+thisNodeType+" with type "+childNodeType+": "+e); |
| return; |
| } |
| } else if ((parentSk == SerializationKind.FOLDER || parentSk == SerializationKind.METADATA_PARTIAL) |
| && childSk == SerializationKind.METADATA_FULL) { |
| createVaultFile((IFolder) resource, serializationManager.getOsPath(childNodeName) + ".xml", childNodeType); |
| } else if (parentSk==SerializationKind.FOLDER && childSk==SerializationKind.METADATA_PARTIAL) { |
| // createVaultFile((IFolder)resource, childNodeName+".xml", childNodeType); |
| |
| IWorkspaceRunnable r = new IWorkspaceRunnable() { |
| |
| @Override |
| public void run(IProgressMonitor monitor) throws CoreException { |
| IFolder f = (IFolder)resource; |
| IFolder newFolder = null; |
| newFolder = f.getFolder(serializationManager.getOsPath(childNodeName)); |
| newFolder.create(true, true, new NullProgressMonitor()); |
| createVaultFile(newFolder, ".content.xml", childNodeType); |
| } |
| }; |
| |
| try { |
| ResourcesPlugin.getWorkspace().run(r, null); |
| } catch (CoreException e) { |
| Activator.getDefault().getPluginLogger().error("Error creating child "+childNodeName+": "+e, e); |
| e.printStackTrace(); |
| MessageDialog.openError(Display.getDefault().getActiveShell(), "Error creating node", "Error creating child of "+thisNodeType+" with type "+childNodeType+": "+e); |
| return; |
| } |
| |
| } else if (parentSk!=SerializationKind.FOLDER && childSk==SerializationKind.METADATA_PARTIAL) { |
| createDomChild(childNodeName, childNodeType); |
| } else { |
| if (childNodeType.equals("nt:file")) { |
| IFolder f = (IFolder)resource; |
| createNtFile(f, childNodeName, childNodeType); |
| return; |
| } |
| //TODO: FILE not yet supported |
| |
| Activator.getDefault().getPluginLogger() |
| .error("Cannot create child node of type " + childNodeType + ", serializationKind " + childSk |
| + " under child node of type " + thisNodeType + ", serializationKind " + parentSk); |
| |
| MessageDialog.openWarning(Display.getDefault().getActiveShell(), "Error creating node", "Cannot create child of "+thisNodeType+" with type "+childNodeType+" (yet?)"); |
| return; |
| } |
| } |
| |
| void createDomChild(String childNodeName, String childNodeType) { |
| boolean underlyingMatch = underlying==properties.getUnderlying(); |
| if (domElement==properties.getDomElement()) { |
| // normal case |
| try{ |
| createChild(childNodeName, childNodeType, domElement, underlying); |
| } catch(Exception e) { |
| MessageDialog.openError(Display.getDefault().getActiveShell(), "Error creating new JCR node", "The following error occurred: "+e.getMessage()); |
| } |
| } else { |
| // trickier case |
| try{ |
| createChild(childNodeName, childNodeType, properties.getDomElement(), properties.getUnderlying()); |
| } catch(Exception e) { |
| MessageDialog.openError(Display.getDefault().getActiveShell(), "Error creating new JCR node", "The following error occurred: "+e.getMessage()); |
| } |
| |
| } |
| } |
| |
| private void createVaultFile(IFolder parent, String filename, String childNodeType) { |
| createVaultFileWithContent(parent, filename, childNodeType, null); |
| } |
| |
| private void createVaultFileWithContent(IFolder parent, String filename, String childNodeType, Element content) { |
| String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<jcr:root \n xmlns:sling=\"http://sling.apache.org/jcr/sling/1.0\"\n xmlns:jcr=\"http://www.jcp.org/jcr/1.0\"\n jcr:primaryType=\""+childNodeType+"\"/>"; |
| final IFile file = parent.getFile(filename); |
| try { |
| if (content!=null) { |
| Document document = TolerantXMLParser.parse(xml, file.getFullPath().toOSString()); |
| // add the attributes of content |
| List<Attribute> attributes = content.getAttributes(); |
| for (Attribute attribute : attributes) { |
| if (attribute.getName().equals("jcr:primaryType")) { |
| // skip this |
| continue; |
| } |
| document.getRootElement().addAttribute(attribute); |
| } |
| // then copy all the children |
| document.getRootElement().addNodes(content.getChildren()); |
| |
| // then save the document |
| xml = document.toXML(); |
| } |
| if (file.exists()) { |
| file.setContents(new ByteArrayInputStream(xml.getBytes()), true, true, new NullProgressMonitor()); |
| } else { |
| file.create(new ByteArrayInputStream(xml.getBytes()), true, new NullProgressMonitor()); |
| } |
| } catch (Exception e) { |
| //TODO proper logging |
| e.printStackTrace(); |
| MessageDialog.openInformation(Display.getDefault().getActiveShell(), |
| "Cannot create JCR node on a File", "Following Exception encountered: "+e); |
| } |
| } |
| |
| private void createNtFile(IFolder parent, String filename, String childNodeType) { |
| IFile file = parent.getFile(filename); |
| if (file.exists()) { |
| // file already exists |
| return; |
| } |
| try { |
| file.create(new ByteArrayInputStream("".getBytes()), true, new NullProgressMonitor()); |
| } catch (CoreException e) { |
| //TODO proper logging |
| e.printStackTrace(); |
| MessageDialog.openWarning(Display.getDefault().getActiveShell(), |
| "Cannot create file "+filename, "Following Exception encountered: "+e); |
| } |
| } |
| |
| private SerializationKind getFallbackSerializationKind(String nodeType) { |
| if (nodeType.equals("nt:file")) { |
| return SerializationKind.FILE; |
| } else if (probablyFolderType(nodeType)) { |
| return SerializationKind.FOLDER; |
| } else { |
| return SerializationKind.METADATA_PARTIAL; |
| } |
| } |
| |
| protected void createChild(String nodeName, String nodeType, |
| Element domElement, GenericJcrRootFile effectiveUnderlying) { |
| if (domElement==null) { |
| throw new IllegalArgumentException("domNode must not be null"); |
| } |
| if (effectiveUnderlying==null) { |
| throw new IllegalArgumentException("effectiveUnderlying must not be null"); |
| } |
| Element element = new Element(nodeName); |
| if (nodeType!=null) { |
| element.addAttribute("jcr:primaryType", nodeType); |
| } |
| StringBuilder indent = new StringBuilder(); |
| Element parElement = domElement.getParentElement(); |
| while(parElement!=null) { |
| indent.append(" "); |
| parElement = parElement.getParentElement(); |
| } |
| domElement.addNode(new Text("\n "+indent.toString())); |
| element = domElement.addNode(element); |
| domElement.addNode(new Text("\n"+indent.toString())); |
| JcrNode childNode = new JcrNode(this, element, null); |
| effectiveUnderlying.save(); |
| } |
| |
| public boolean canBeDeleted() { |
| if (parent==null) { |
| return false; |
| } |
| if (resource!=null) { |
| // can be a file or a folder (project is virtually impossible) |
| return true; |
| } |
| if (domElement!=null && underlying!=null) { |
| return true; |
| } |
| return false; |
| } |
| |
| public void delete() { |
| if (parent==null) { |
| // then I dont know how to delete |
| return; |
| } |
| parent.children.remove(this); |
| if (resource!=null) { |
| IWorkspaceRunnable r = new IWorkspaceRunnable() { |
| |
| @Override |
| public void run(IProgressMonitor monitor) throws CoreException { |
| resource.delete(true, monitor); |
| if (dirSibling!=null) { |
| dirSibling.getResource().delete(true, monitor); |
| } |
| } |
| }; |
| try { |
| ResourcesPlugin.getWorkspace().run(r, null); |
| } catch (CoreException e) { |
| Activator.getDefault().getPluginLogger().error("Error renaming resource ("+resource+"): "+e, e); |
| } |
| } |
| if (domElement!=null) { |
| Element parentNode = domElement.getParentElement(); |
| domElement.remove(); |
| if (parentNode!=null) { |
| List<Node> allChildNodes = parentNode.getNodes(); |
| boolean nonTextChild = false; |
| for (Iterator<Node> it = allChildNodes.iterator(); it |
| .hasNext();) { |
| Node node = it.next(); |
| if (node.getType()!=Type.TEXT) { |
| nonTextChild = true; |
| } |
| } |
| if (!nonTextChild) { |
| for (Iterator<Node> it = allChildNodes.iterator(); it |
| .hasNext();) { |
| Node node = it.next(); |
| it.remove(); |
| } |
| if (!parentNode.hasNodes()) { |
| parentNode.setCompactEmpty(true); |
| } |
| } |
| } |
| } |
| if (underlying!=null) { |
| underlying.save(); |
| } |
| } |
| |
| public IProject getProject() { |
| if (resource!=null) { |
| return resource.getProject(); |
| } |
| if (underlying!=null) { |
| return underlying.file.getProject(); |
| } |
| return null; |
| } |
| |
| public boolean isInContentXml() { |
| return domElement!=null; |
| } |
| |
| public boolean canCreateChild() { |
| try { |
| final IProject project = getProject(); |
| final Filter filter = ProjectUtil.loadFilter(project); |
| final String relativeFilePath = getJcrPath(); |
| // final Repository repository = Activator.getDefault().getRepositoryFactory().newRepository(null);//ServerUtil.getRepository(null, null); |
| // final RepositoryInfo repositoryInfo = repository.getRepositoryInfo(); |
| // if (repositoryInfo==null) { |
| // return false; |
| // } |
| if (filter==null) { |
| Activator.getDefault().getPluginLogger().error("No filter.xml found for "+project); |
| return true; |
| } else { |
| final FilterResult result = filter.filter(relativeFilePath); |
| return result==FilterResult.ALLOW; |
| } |
| } catch (CoreException e) { |
| Logger logger = Activator.getDefault().getPluginLogger(); |
| logger.error("Could not verify child node allowance: "+this, e); |
| return false; |
| } |
| } |
| |
| public String getPrimaryType() { |
| final String pt = properties.getValue("jcr:primaryType"); |
| if (pt!=null && pt.length()!=0) { |
| return pt; |
| } |
| if (resource!=null) { |
| if (resource instanceof IContainer) { |
| return "nt:folder"; |
| } else { |
| return "nt:file"; |
| } |
| } |
| return ""; |
| } |
| |
| public void deleteProperty(String displayName) { |
| properties.deleteProperty(displayName); |
| } |
| |
| public SyncDir getSyncDir() { |
| return getParent().getSyncDir(); |
| } |
| |
| public void setPropertyValue(Object key, Object value) { |
| properties.setPropertyValue(key, value); |
| } |
| |
| void changePrimaryType(String newPrimaryType) { |
| Repository repository = ServerUtil.getDefaultRepository(getProject()); |
| NodeTypeRegistry ntManager = (repository==null) ? null : repository.getNodeTypeRegistry(); |
| if (ntManager == null) { |
| MessageDialog.openWarning(null, "Unable to change primary type", "Unable to change primary type since project " |
| + getProject().getName() + " is not associated with a server or the server is not started."); |
| return; |
| } |
| |
| try { |
| if (!ntManager.isAllowedPrimaryChildNodeType(getParent().getPrimaryType(), newPrimaryType)) { |
| if (!MessageDialog.openQuestion(null, "Unable to change primary type", "Parent (type '"+getParent().getPrimaryType()+"')"+ |
| " does not accept child with primary type '"+newPrimaryType+"'. Change anyway?")) { |
| return; |
| } |
| } |
| } catch (RepositoryException e1) { |
| MessageDialog.openWarning(null, "Unable to change primary type", "Exception occured while trying to "+ |
| "verify node types: "+e1); |
| return; |
| } |
| String thisNodeType = getPrimaryType(); |
| final SerializationKind currentSk = getSerializationKind(thisNodeType); |
| final SerializationKind newSk = getSerializationKind(newPrimaryType); |
| |
| if (currentSk.equals(newSk)) { |
| if (newSk!=SerializationKind.FOLDER) { |
| // easiest - we should just be able to change the type in the .content.xml |
| properties.doSetPropertyValue("jcr:primaryType", newPrimaryType); |
| } else { |
| if (thisNodeType.equals("nt:folder")) { |
| // switching away from an nt:folder might require creating a .content.xml |
| createVaultFile((IFolder) resource, ".content.xml", newPrimaryType); |
| } else if (newPrimaryType.equals("nt:folder")) { |
| // switching *to* an nt:folder also has its challenges..: |
| // 1) it is not allowed to occur within a 'default' and 'full coverage aggregate' node |
| // 2) nt:folder doesn't allow arbitrary children for one |
| // 3) but it also doesn't have an extra .content.xml - so that one would disappear |
| |
| // 1) |
| if (domElement!=null) { |
| MessageDialog.openWarning(null, "Unable to change primaryType", "Unable to change jcr:primaryType to nt:folder" |
| + " since the node is contained in a .content.xml"); |
| return; |
| } |
| |
| |
| // verify 2) |
| if (!verifyNodeTypeChange(ntManager, newPrimaryType)) { |
| return; |
| } |
| if (!(resource instanceof IFolder)) { |
| MessageDialog.openWarning(null, "Unable to change primaryType", "Unable to change jcr:primaryType to nt:folder" |
| + " as there is no underlying folder"); |
| return; |
| } |
| IFolder folder = (IFolder)resource; |
| // 3) delete the .content.xml |
| IFile contentXml = folder.getFile(".content.xml"); |
| if (contentXml.exists()) { |
| try { |
| contentXml.delete(true, new NullProgressMonitor()); |
| } catch (CoreException e) { |
| Logger logger = Activator.getDefault().getPluginLogger(); |
| logger.error("Could not delete "+contentXml.getFullPath()+", e="+e, e); |
| MessageDialog.openError(null, "Could not delete file", |
| "Could not delete "+contentXml.getFullPath()+", "+e); |
| } |
| } |
| } else { |
| properties.doSetPropertyValue("jcr:primaryType", newPrimaryType); |
| } |
| } |
| return; |
| } |
| |
| if (newSk==SerializationKind.FOLDER) { |
| // switching to a folder |
| if (currentSk==SerializationKind.FILE) { |
| MessageDialog.openWarning(null, "Unable to change primary type", |
| "Changing from a file to a folder type is currently not supported"); |
| return; |
| } |
| if (newPrimaryType.equals("nt:folder")) { |
| // verify |
| if (!verifyNodeTypeChange(ntManager, newPrimaryType)) { |
| return; |
| } |
| } |
| try { |
| // create the new directory structure pointing to 'this' |
| IFolder newFolder = getParent().prepareCreateFolderChild(getJcrPathName()); |
| |
| if (!newPrimaryType.equals("nt:folder")) { |
| // move any children from the existing 'this' to a new vault file |
| createVaultFileWithContent(newFolder, ".content.xml", newPrimaryType, domElement); |
| } |
| |
| // remove myself |
| if (domElement!=null) { |
| domElement.remove(); |
| if (underlying!=null) { |
| underlying.save(); |
| } |
| } |
| |
| // add a pointer in the corresponding .content.xml to point to this (folder) child |
| getParent().createDomChild(getJcrPathName(), |
| null); |
| if (newPrimaryType.equals("nt:folder")) { |
| // delete the .content.xml |
| if (properties!=null && properties.getUnderlying()!=null) { |
| IFile contentXml = properties.getUnderlying().file; |
| if (contentXml!=null && contentXml.exists()) { |
| contentXml.delete(true, new NullProgressMonitor()); |
| } |
| } |
| } |
| ServerUtil.triggerIncrementalBuild(newFolder, null); |
| return; |
| } catch (CoreException e) { |
| MessageDialog.openWarning(null, "Unable to change primaryType", "Exception occurred: "+e); |
| Logger logger = Activator.getDefault().getPluginLogger(); |
| logger.error("Exception occurred", e); |
| return; |
| } |
| } else if (newSk==SerializationKind.FILE) { |
| MessageDialog.openWarning(null, "Unable to change primary type", |
| "Changing to/from a file is currently not supported"); |
| return; |
| } else { |
| // otherwise we're going from a folder to partial-or-full |
| if (domElement==null && (resource instanceof IFolder)) { |
| createVaultFile((IFolder) resource, ".content.xml", newPrimaryType); |
| } else { |
| |
| // set the "pointer"'s jcr:primaryType |
| if (domElement.getAttributeMap().containsKey("jcr:primaryType")) { |
| domElement.setAttribute("jcr:primaryType", newPrimaryType); |
| } else { |
| domElement.addAttribute("jcr:primaryType", newPrimaryType); |
| } |
| |
| // then copy all the other attributes - plus children if there are nay |
| Element propDomElement = properties.getDomElement(); |
| if (propDomElement!=null) { |
| List<Attribute> attributes = propDomElement.getAttributes(); |
| for (Iterator<Attribute> it = attributes.iterator(); it.hasNext();) { |
| Attribute anAttribute = it.next(); |
| if (anAttribute.getName().startsWith("xmlns:")) { |
| continue; |
| } |
| if (anAttribute.getName().equals("jcr:primaryType")) { |
| continue; |
| } |
| if (domElement.getAttributeMap().containsKey(anAttribute.getName())) { |
| domElement.setAttribute(anAttribute.getName(), anAttribute.getValue()); |
| } else { |
| domElement.addAttribute(anAttribute); |
| } |
| } |
| List<Element> c2 = propDomElement.getChildren(); |
| if (c2!=null && c2.size()!=0) { |
| domElement.addNodes(c2); |
| } |
| } |
| |
| if (properties.getUnderlying()!=null && properties.getUnderlying().file!=null) { |
| try { |
| properties.getUnderlying().file.delete(true, new NullProgressMonitor()); |
| // prune empty directories: |
| prune(properties.getUnderlying().file.getParent()); |
| } catch (CoreException e) { |
| MessageDialog.openError(null, "Unable to change primary type", |
| "Could not delete vault file "+properties.getUnderlying().file+": "+e); |
| Activator.getDefault().getPluginLogger().error("Error changing jcr:primaryType. Could not delete vault file "+properties.getUnderlying().file+": "+e.getMessage(), e); |
| return; |
| } |
| } |
| |
| underlying.save(); |
| } |
| } |
| |
| } |
| |
| private void prune(IContainer folder) throws CoreException { |
| if (folder==null || !(folder instanceof IFolder)) { |
| return; |
| } |
| IFolder f = (IFolder)folder; |
| IResource[] members = f.members(); |
| if (members!=null && members.length!=0) { |
| return; |
| } |
| f.delete(true, new NullProgressMonitor()); |
| prune(folder.getParent()); |
| } |
| |
| private boolean verifyNodeTypeChange(NodeTypeRegistry ntManager, |
| final String newNodeType) { |
| Object[] cn = getChildren(true); |
| for (int i = 0; i < cn.length; i++) { |
| JcrNode node = (JcrNode) cn[i]; |
| try { |
| if (!ntManager.isAllowedPrimaryChildNodeType(newNodeType, node.getPrimaryType())) { |
| MessageDialog.openWarning(null, "Unable to change primaryType", "Unable to change jcr:primaryType to nt:folder" |
| + " since nt:folder cannot have child of type "+node.getPrimaryType()); |
| return false; |
| } |
| } catch (RepositoryException e) { |
| Logger logger = Activator.getDefault().getPluginLogger(); |
| logger.error("Could not determine allowed primary child node types", e); |
| } |
| } |
| return true; |
| } |
| |
| public void addProperty(String name, String value) { |
| properties.addProperty(name, value); |
| } |
| |
| public NodeType getNodeType() { |
| Repository repository = ServerUtil.getDefaultRepository(getProject()); |
| NodeTypeRegistry ntManager = (repository==null) ? null : repository.getNodeTypeRegistry(); |
| if (ntManager==null) { |
| return null; |
| } |
| return ntManager.getNodeType(getPrimaryType()); |
| } |
| |
| public int getPropertyType(String propertyName) { |
| PropertyDefinition pd = getPropertyDefinition(propertyName); |
| if (pd!=null) { |
| return pd.getRequiredType(); |
| } |
| |
| // otherwise use the SerializationManager to read the |
| // underlying vault file and derive the propertyType from there |
| GenericJcrRootFile u = properties.getUnderlying(); |
| if (u==null) { |
| // no underlying properties file, that's not good |
| Activator.getDefault().getPluginLogger().warn("No underlying properties file, cannot derive propertyType ("+propertyName+") for "+this); |
| return -1; |
| } |
| |
| IFolder contentSyncRoot = ProjectUtil.getSyncDirectory(getProject()); |
| IFile file = (IFile) u.file; |
| try (InputStream contents = file.getContents() ){ |
| String resourceLocation = file.getFullPath().makeRelativeTo(contentSyncRoot.getFullPath()) |
| .toPortableString(); |
| ResourceProxy resourceProxy = Activator.getDefault() |
| .getSerializationManager().readSerializationData(resourceLocation, contents); |
| |
| // resourceProxy could be containing a full tree |
| // dive into the right position |
| String rawValue = properties.getValue(propertyName); |
| return PropertyTypeSupport.propertyTypeOfString(rawValue); |
| } catch(Exception e) { |
| Activator.getDefault().getPluginLogger().warn("Exception occurred during analyzing propertyType ("+propertyName+") for "+this, e); |
| } |
| return -1; |
| } |
| |
| private Object doGetProperty(ResourceProxy resourceProxy, |
| String propertyName) { |
| if (resourceProxy.getPath().equals(getJcrPath())) { |
| Map<String, Object> props = resourceProxy.getProperties(); |
| if (props.containsKey(propertyName)) { |
| Object p0 = props.get(propertyName); |
| return p0; |
| } |
| } else { |
| List<ResourceProxy> resourceProxyChildren = resourceProxy.getChildren(); |
| for (Iterator<ResourceProxy> it = resourceProxyChildren.iterator(); it |
| .hasNext();) { |
| final ResourceProxy aChild = it.next(); |
| final Object p1 = doGetProperty(aChild, propertyName); |
| if (p1!=null) { |
| return p1; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public PropertyDefinition getPropertyDefinition(String propertyName) { |
| NodeType nt0 = getNodeType(); |
| if (nt0==null) { |
| return null; |
| } |
| List<NodeType> nodeTypes = new LinkedList<>(); |
| nodeTypes.add(nt0); |
| // add all supertypes |
| nodeTypes.addAll(Arrays.asList(nt0.getSupertypes())); |
| for (Iterator<NodeType> it = nodeTypes.iterator(); it.hasNext();) { |
| NodeType nt = it.next(); |
| PropertyDefinition[] pds = nt.getPropertyDefinitions(); |
| for (int i = 0; i < pds.length; i++) { |
| PropertyDefinition propertyDefinition = pds[i]; |
| if (propertyDefinition.getName().equals(propertyName)) { |
| return propertyDefinition; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public JcrProperty getProperty(final String name) { |
| if (properties==null) { |
| return null; |
| } |
| return new JcrProperty() { |
| |
| @Override |
| public String getName() { |
| return name; |
| } |
| |
| |
| @Override |
| public int getType() { |
| return getPropertyType(name); |
| } |
| |
| @Override |
| public String getTypeAsString() { |
| int t = getPropertyType(name); |
| return PropertyType.nameFromValue(t); |
| }; |
| |
| // @Override |
| // public Object getValue() { |
| // throw new IllegalStateException("not yet implemented"); |
| // } |
| |
| @Override |
| public String getValueAsString() { |
| String rawValue = getProperties().getValue(name); |
| if (rawValue==null) { |
| return null; |
| } |
| if (rawValue.startsWith("{")) { |
| int curlyEnd = rawValue.indexOf("}", 1); |
| rawValue = rawValue.substring(curlyEnd+1); |
| } |
| return rawValue; |
| } |
| |
| @Override |
| public boolean isMultiple() { |
| String rawValue = getProperties().getValue(name); |
| if (rawValue==null) { |
| return false; |
| } |
| if (rawValue.startsWith("{")) { |
| int curlyEnd = rawValue.indexOf("}", 1); |
| rawValue = rawValue.substring(curlyEnd+1); |
| } |
| return rawValue.startsWith("[") && rawValue.endsWith("]"); |
| } |
| |
| @Override |
| public String[] getValuesAsString() { |
| String rawValue = getProperties().getValue(name); |
| if (rawValue.startsWith("{")) { |
| int curlyEnd = rawValue.indexOf("}", 1); |
| rawValue = rawValue.substring(curlyEnd+1); |
| } |
| rawValue = rawValue.substring(1, rawValue.length()-1); |
| return org.apache.jackrabbit.util.Text.explode(rawValue, ','); |
| } |
| }; |
| } |
| |
| public void renameProperty(String oldKey, String newKey) { |
| properties.renameProperty(oldKey, newKey); |
| } |
| |
| public void changePropertyType(String key, int propertyType) { |
| properties.changePropertyType(key, propertyType); |
| } |
| |
| private IFolder prepareCreateFolderChild(final String childNodeName) |
| throws CoreException { |
| // 0) find base folder for creating new subfolders |
| List<String> parentNames = new LinkedList<>(); |
| JcrNode node = JcrNode.this; |
| while(!(node.resource instanceof IFolder) && !(node instanceof SyncDir)) { |
| parentNames.add(0, node.getJcrPathName()); |
| node = node.getParent(); |
| } |
| if (!(node.resource instanceof IFolder)) { |
| throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Could not find base folder for creating child. (1) Expected a folder at "+node.resource)); |
| } |
| IFolder folder = (IFolder) node.resource; |
| parentNames.add(childNodeName); |
| for (Iterator<String> it = parentNames.iterator(); it .hasNext();) { |
| String aParentName = it.next(); |
| String encodedParentName = DirNode.encode(aParentName); |
| IResource member = folder.findMember(encodedParentName); |
| if (member!=null && !(member instanceof IFolder)) { |
| throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Could not find base folder for creating child. (2) Expected a folder at "+member)); |
| } |
| if (member!=null && member.exists()) { |
| folder = (IFolder) member; |
| it.remove(); |
| continue; |
| } |
| folder = folder.getFolder(encodedParentName); |
| if (!folder.exists()) { |
| folder.create(true, true, new NullProgressMonitor()); |
| } |
| } |
| |
| return folder; |
| } |
| |
| public IStatus validateDrop(int operation, TransferData transferType) { |
| Repository repository = ServerUtil.getDefaultRepository(getProject()); |
| NodeTypeRegistry ntManager = (repository==null) ? null : repository.getNodeTypeRegistry(); |
| if (ntManager == null) { |
| return new Status(IStatus.CANCEL, Activator.PLUGIN_ID, 1, "Cannot drop element here because corresponding server is not started! (Needed to determine node types)", null); |
| } |
| // let's support plain files first |
| try { |
| if (getPrimaryType().equals("nt:file")) { |
| // hard-code the most prominent case: cannot drop onto a file |
| return new Status(IStatus.CANCEL, Activator.PLUGIN_ID, 1, "Cannot drop element onto nt:file", null); |
| } |
| if (ntManager.isAllowedPrimaryChildNodeType(getPrimaryType(), "nt:file")) { |
| return Status.OK_STATUS; |
| } else { |
| return Status.CANCEL_STATUS; |
| } |
| } catch (RepositoryException e) { |
| Activator.getDefault().getPluginLogger().error("validateDrop: Got Exception while " |
| + "verifying nodeType: "+e, e); |
| return Status.CANCEL_STATUS; |
| } |
| } |
| |
| public IStatus handleDrop(Object data, int detail) throws CoreException { |
| IFolder folder = (IFolder)this.resource; |
| if (data instanceof IStructuredSelection) { |
| IStructuredSelection sel = (IStructuredSelection)data; |
| Object firstElem = sel.getFirstElement(); |
| if (firstElem instanceof IResource) { |
| IResource resource = (IResource)firstElem; |
| return handleDropResource(folder, resource, detail); |
| } else if (firstElem instanceof JcrNode) { |
| JcrNode node = (JcrNode)firstElem; |
| return handleDropNode(folder, node, detail); |
| } else { |
| return new Status(IStatus.CANCEL, Activator.PLUGIN_ID, 1, "Cannot drop on this type of element (yet) [1]", null); |
| } |
| } else { |
| return new Status(IStatus.CANCEL, Activator.PLUGIN_ID, 1, "Cannot drop this type of selection", null); |
| } |
| } |
| |
| private IStatus handleDropNode(IFolder targetFolder, JcrNode droppedNode, int dropDetail) throws CoreException { |
| if (domElement!=null && droppedNode.domElement!=null && droppedNode.resource==null) { |
| // then this is the case of moving/copying a dom tree |
| domElement.addNodes(droppedNode.domElement.copy()); |
| underlying.save(); |
| if (dropDetail==DND.DROP_MOVE) { |
| // then delete the original |
| droppedNode.delete(); |
| } |
| return Status.OK_STATUS; |
| } |
| |
| if (droppedNode.resource!=null && droppedNode.domElement==null) { |
| // this is a pure file/folder based d'n'd |
| IStatus status = handleDropResource(targetFolder, droppedNode.resource, dropDetail); |
| if (!status.isOK()) { |
| return status; |
| } |
| if (droppedNode.dirSibling!=null) { |
| return handleDropResource(targetFolder, droppedNode.dirSibling.getResource(), dropDetail); |
| } |
| return Status.OK_STATUS; |
| } |
| //TODO mixed cases are more advanced and not yet supported |
| return new Status(IStatus.CANCEL, Activator.PLUGIN_ID, 1, "Cannot drop on this (mixed) type of element (yet) [2]", null); |
| } |
| |
| private IStatus handleDropResource(IFolder targetFolder, |
| IResource droppedResourceRoot, int detail) throws CoreException { |
| if (targetFolder==null) { |
| return new Status(IStatus.CANCEL, Activator.PLUGIN_ID, 1, "Cannot drop on this type of element (yet)", null); |
| } |
| if (droppedResourceRoot==null) { |
| throw new IllegalArgumentException("droppedResourceRoot must not be null"); |
| } |
| IFile copyToFile = targetFolder.getFile(droppedResourceRoot.getName()); |
| IPath copyToPath = copyToFile.getFullPath(); |
| switch (detail) { |
| case DND.DROP_COPY: { |
| droppedResourceRoot.copy(copyToPath, true, |
| new NullProgressMonitor()); |
| break; |
| } |
| case DND.DROP_MOVE: { |
| droppedResourceRoot.move(copyToPath, true, |
| new NullProgressMonitor()); |
| break; |
| } |
| default: { |
| throw new IllegalStateException("Unknown drop action (detail: " |
| + detail + ")"); |
| } |
| } |
| return Status.OK_STATUS; |
| } |
| |
| public IContainer getDropContainer() { |
| if (resource instanceof IContainer) { |
| return (IContainer) resource; |
| } else { |
| return null; |
| } |
| } |
| |
| public boolean canBeCopiedToClipboard() { |
| if (getPrimaryType().equals("nt:file")) { |
| return true; |
| } else if (domElement!=null && resource==null) { |
| // plain dom node/sub-tree - which we support via XML |
| return true; |
| } else { |
| // everything else: not yet supported |
| return false; |
| } |
| } |
| |
| public void copyToClipboard(Clipboard clipboard) { |
| if (!canBeCopiedToClipboard()) { |
| MessageDialog.openWarning(null, "Cannot copy", "Cannot copy this type of node (yet)"); |
| return; |
| } |
| if (getPrimaryType().equals("nt:file")) { |
| copyFileToClipboard(clipboard); |
| } else if (domElement!=null && resource==null) { |
| copyDomToClipboard(clipboard); |
| } |
| } |
| |
| private void copyDomToClipboard(Clipboard clipboard) { |
| String text = domElement.toXML(); |
| clipboard.setContents(new Object[] {text}, new Transfer[] {TextTransfer.getInstance()}); |
| } |
| |
| private void copyFileToClipboard(Clipboard clipboard) { |
| final IResource[] resources; |
| final String[] fileNames; |
| if (dirSibling==null) { |
| resources = new IResource[] {resource}; |
| final IPath location = resource.getLocation(); |
| fileNames = (location==null) ? null : new String[] {location.toOSString()}; |
| } else { |
| resources = new IResource[] {resource, dirSibling.getResource()}; |
| final IPath resLocation = resource.getLocation(); |
| final IPath siblLocation = dirSibling.getResource().getLocation(); |
| fileNames = (resLocation==null || siblLocation==null) ? null : new String[] {resLocation.toOSString(), siblLocation.toOSString()}; |
| } |
| if (fileNames!=null) { |
| clipboard.setContents(new Object[] { resources, fileNames }, |
| new Transfer[] { ResourceTransfer.getInstance(), |
| FileTransfer.getInstance()}); |
| } else { |
| clipboard.setContents(new Object[] { resources }, |
| new Transfer[] { ResourceTransfer.getInstance() }); |
| } |
| } |
| |
| public boolean canBePastedTo(Clipboard clipboard) { |
| Repository repository = ServerUtil.getDefaultRepository(getProject()); |
| NodeTypeRegistry ntManager = (repository==null) ? null : repository.getNodeTypeRegistry(); |
| |
| IResource[] resourceData = (IResource[]) clipboard |
| .getContents(ResourceTransfer.getInstance()); |
| if (resourceData!=null) { |
| IContainer container = getDropContainer(); |
| return container!=null; |
| } |
| |
| String[] fileData = (String[]) clipboard.getContents(FileTransfer.getInstance()); |
| if (fileData!=null) { |
| IContainer container = getDropContainer(); |
| return container!=null; |
| } |
| |
| String text = (String) clipboard.getContents(TextTransfer.getInstance()); |
| if (text!=null) { |
| return (domElement!=null); |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Paste from the clipboard to this (container) node. |
| * <p> |
| * Copyright Note: The code of this method was ported from eclipse' |
| * PasteAction, which due to visibility restrictions was not reusable. |
| * <p> |
| * @param clipboard |
| */ |
| public void pasteFromClipboard(Clipboard clipboard) { |
| if (!canBePastedTo(clipboard)) { |
| // should not occur due to 'canBePastedTo' check done by |
| // corresponding action - checking here nevertheless |
| MessageDialog.openInformation(null, "Cannot paste", |
| "No applicable node (type) for pasting found."); |
| return; |
| } |
| Repository repository = ServerUtil.getDefaultRepository(getProject()); |
| NodeTypeRegistry ntManager = (repository==null) ? null : repository.getNodeTypeRegistry(); |
| if (ntManager == null) { |
| MessageDialog.openWarning(null, "Cannot paste", "Cannot paste if corresponding server is not started"); |
| return; |
| } |
| |
| // try the resource transfer |
| IResource[] resourceData = (IResource[]) clipboard.getContents(ResourceTransfer.getInstance()); |
| |
| if (resourceData != null && resourceData.length > 0) { |
| if (resourceData[0].getType() == IResource.PROJECT) { |
| // do not support project pasting onto a jcr node |
| MessageDialog.openInformation(null, "Cannot paste project(s)", |
| "Pasting of a project onto a (JCR) node is not possible"); |
| return; |
| } else { |
| CopyFilesAndFoldersOperation operation = new CopyFilesAndFoldersOperation(null); |
| operation.copyResources(resourceData, getDropContainer()); |
| } |
| return; |
| } |
| |
| // try the file transfer |
| String[] fileData = (String[]) clipboard.getContents(FileTransfer.getInstance()); |
| if (fileData != null) { |
| CopyFilesAndFoldersOperation operation = new CopyFilesAndFoldersOperation(null); |
| operation.copyFiles(fileData, getDropContainer()); |
| return; |
| } |
| |
| // then try the text transfer |
| String text = (String) clipboard.getContents(TextTransfer.getInstance()); |
| if ((text!=null) && (this.domElement!=null)) { |
| try { |
| Document document = TolerantXMLParser.parse(text, "pasted from clipboard"); |
| this.domElement.addNode(document.getRootElement()); |
| this.underlying.save(); |
| } catch (IOException e) { |
| MessageDialog.openError(null, "Could not paste from clipboard", |
| "Exception encountered while pasting from clipboard: "+e); |
| Activator.getDefault().getPluginLogger().error("Error pasting from clipboard: "+e, e); |
| } |
| } |
| } |
| |
| } |
