X-Git-Url: http://git.argeo.org/?a=blobdiff_plain;f=org.argeo.cms.jcr%2Fsrc%2Forg%2Fargeo%2Fcms%2Fjcr%2Facr%2FJcrContent.java;h=9e662ecc96ab8dcbf128c452ba1c1f42acfc661f;hb=940ce9759c33a2f409fb4491a05b0edb892584c7;hp=dea60b91c2a3112630deba4d4b33d2c23310a06b;hpb=cae8b15557882d8cf12aade6bb8a627e9a6a680f;p=gpl%2Fargeo-jcr.git diff --git a/org.argeo.cms.jcr/src/org/argeo/cms/jcr/acr/JcrContent.java b/org.argeo.cms.jcr/src/org/argeo/cms/jcr/acr/JcrContent.java index dea60b9..9e662ec 100644 --- a/org.argeo.cms.jcr/src/org/argeo/cms/jcr/acr/JcrContent.java +++ b/org.argeo.cms.jcr/src/org/argeo/cms/jcr/acr/JcrContent.java @@ -5,14 +5,18 @@ import java.io.IOException; import java.io.InputStream; import java.io.PipedInputStream; import java.io.PipedOutputStream; +import java.time.Instant; import java.util.ArrayList; import java.util.Calendar; +import java.util.Date; +import java.util.GregorianCalendar; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Optional; import java.util.Set; import java.util.TreeSet; +import java.util.UUID; import java.util.concurrent.ForkJoinPool; import javax.jcr.Node; @@ -23,14 +27,16 @@ import javax.jcr.PropertyType; import javax.jcr.RepositoryException; import javax.jcr.Session; import javax.jcr.Value; +import javax.jcr.ValueFactory; import javax.jcr.nodetype.NodeType; +import javax.jcr.nodetype.NodeTypeManager; import javax.xml.namespace.QName; import javax.xml.transform.Source; import javax.xml.transform.stream.StreamSource; import org.argeo.api.acr.Content; +import org.argeo.api.acr.CrAttributeType; import org.argeo.api.acr.NamespaceUtils; -import org.argeo.api.acr.spi.ContentProvider; import org.argeo.api.acr.spi.ProvidedSession; import org.argeo.api.cms.CmsConstants; import org.argeo.cms.acr.AbstractContent; @@ -41,8 +47,6 @@ import org.argeo.jcr.JcrUtils; /** A JCR {@link Node} accessed as {@link Content}. */ public class JcrContent extends AbstractContent { -// private Node jcrNode; - private JcrContentProvider provider; private String jcrWorkspace; @@ -50,6 +54,16 @@ public class JcrContent extends AbstractContent { private final boolean isMountBase; + /* OPTIMISATIONS */ + /** + * While we want to support thread-safe access, it is very likely that only + * thread and only one sesssion will be used (typically from a single-threaded + * UI). We therefore cache was long as the same thread is calling. + */ + private Thread lastRetrievingThread = null; + private Node cachedNode = null; + private boolean caching = true; + protected JcrContent(ProvidedSession session, JcrContentProvider provider, String jcrWorkspace, String jcrPath) { super(session); this.provider = provider; @@ -59,6 +73,10 @@ public class JcrContent extends AbstractContent { this.isMountBase = ContentUtils.SLASH_STRING.equals(jcrPath); } + /* + * READ + */ + @Override public QName getName() { String name = Jcr.getName(getJcrNode()); @@ -73,10 +91,11 @@ public class JcrContent extends AbstractContent { @SuppressWarnings("unchecked") @Override public Optional get(QName key, Class clss) { - if (isDefaultAttrTypeRequested(clss)) { - return Optional.of((A) get(getJcrNode(), key.toString())); - } - return Optional.of((A) Jcr.get(getJcrNode(), key.toString())); + Object value = get(getJcrNode(), key.toString()); + if (value instanceof List lst) + return Optional.of((A) lst); + // TODO check other collections? + return CrAttributeType.cast(clss, value); } @Override @@ -105,18 +124,11 @@ public class JcrContent extends AbstractContent { } } - public Node getJcrNode() { - try { - // TODO caching? - return provider.getJcrSession(getSession(), jcrWorkspace).getNode(jcrPath); - } catch (RepositoryException e) { - throw new JcrException("Cannot retrieve " + jcrPath + " from workspace " + jcrWorkspace, e); - } - } - /** Cast to a standard Java object. */ static Object get(Node node, String property) { try { + if (!node.hasProperty(property)) + return null; Property p = node.getProperty(property); if (p.isMultiple()) { Value[] values = p.getValues(); @@ -130,57 +142,25 @@ public class JcrContent extends AbstractContent { return convertSingleValue(value); } } catch (RepositoryException e) { - throw new JcrException("Cannot cast value from " + property + " of node " + node, e); + throw new JcrException("Cannot cast value from " + property + " of " + node, e); } } - static Object convertSingleValue(Value value) throws RepositoryException { - switch (value.getType()) { - case PropertyType.STRING: - return value.getString(); - case PropertyType.DOUBLE: - return (Double) value.getDouble(); - case PropertyType.LONG: - return (Long) value.getLong(); - case PropertyType.BOOLEAN: - return (Boolean) value.getBoolean(); - case PropertyType.DATE: - Calendar calendar = value.getDate(); - return calendar.toInstant(); - case PropertyType.BINARY: - throw new IllegalArgumentException("Binary is not supported as an attribute"); - default: - return value.getString(); - } - } - - class JcrContentIterator implements Iterator { - private final NodeIterator nodeIterator; - // we keep track in order to be able to delete it - private JcrContent current = null; - - protected JcrContentIterator(NodeIterator nodeIterator) { - this.nodeIterator = nodeIterator; - } - - @Override - public boolean hasNext() { - return nodeIterator.hasNext(); - } - - @Override - public Content next() { - current = new JcrContent(getSession(), provider, jcrWorkspace, Jcr.getPath(nodeIterator.nextNode())); - return current; - } - - @Override - public void remove() { - if (current != null) { - Jcr.remove(current.getJcrNode()); + @Override + public boolean isMultiple(QName key) { + Node node = getJcrNode(); + String p = NamespaceUtils.toFullyQualified(key); + try { + if (node.hasProperty(p)) { + Property property = node.getProperty(p); + return property.isMultiple(); + } else { + return false; } + } catch (RepositoryException e) { + throw new JcrException( + "Cannot check multiplicityof property " + p + " of " + jcrPath + " in " + jcrWorkspace, e); } - } @Override @@ -188,7 +168,7 @@ public class JcrContent extends AbstractContent { try { // Note: it is important to to use the default way (recursing through parents), // since the session may not have access to parent nodes - return ContentUtils.ROOT_SLASH + jcrWorkspace + getJcrNode().getPath(); + return Content.ROOT_PATH + jcrWorkspace + getJcrNode().getPath(); } catch (RepositoryException e) { throw new JcrException("Cannot get depth of " + getJcrNode(), e); } @@ -217,11 +197,35 @@ public class JcrContent extends AbstractContent { return new JcrContent(getSession(), provider, jcrWorkspace, Jcr.getParentPath(getJcrNode())); } + @Override + public int getSiblingIndex() { + return Jcr.getIndex(getJcrNode()); + } + + /* + * MAP OPTIMISATIONS + */ + @Override + public boolean containsKey(Object key) { + return Jcr.hasProperty(getJcrNode(), key.toString()); + } + + /* + * WRITE + */ + + protected Node openForEdit() { + Node node = getProvider().openForEdit(getSession(), jcrWorkspace, jcrPath); + getSession().notifyModification(this); + return node; + } + @Override public Content add(QName name, QName... classes) { if (classes.length > 0) { QName primaryType = classes[0]; - Node child = Jcr.addNode(getJcrNode(), name.toString(), primaryType.toString()); + Node node = openForEdit(); + Node child = Jcr.addNode(node, name.toString(), primaryType.toString()); for (int i = 1; i < classes.length; i++) { try { child.addMixin(classes[i].toString()); @@ -238,12 +242,14 @@ public class JcrContent extends AbstractContent { @Override public void remove() { - Jcr.remove(getJcrNode()); + Node node = openForEdit(); + Jcr.remove(node); } @Override protected void removeAttr(QName key) { - Property property = Jcr.getProperty(getJcrNode(), key.toString()); + Node node = openForEdit(); + Property property = Jcr.getProperty(node, key.toString()); if (property != null) { try { property.remove(); @@ -254,12 +260,54 @@ public class JcrContent extends AbstractContent { } + @Override + public Object put(QName key, Object value) { + try { + String property = NamespaceUtils.toFullyQualified(key); + Node node = openForEdit(); + Object old = null; + if (node.hasProperty(property)) { + old = convertSingleValue(node.getProperty(property).getValue()); + } + Value newValue = convertSingleObject(node.getSession().getValueFactory(), value); + node.setProperty(property, newValue); + // FIXME proper edition + node.getSession().save(); + return old; + } catch (RepositoryException e) { + throw new JcrException("Cannot set property " + key + " on " + jcrPath + " in " + jcrWorkspace, e); + } + } + + @Override + public void addContentClasses(QName... contentClass) throws IllegalArgumentException, JcrException { + try { + Node node = openForEdit(); + NodeTypeManager ntm = node.getSession().getWorkspace().getNodeTypeManager(); + List nodeTypes = new ArrayList<>(); + for (QName clss : contentClass) { + NodeType nodeType = ntm.getNodeType(NamespaceUtils.toFullyQualified(clss)); + if (!nodeType.isMixin()) + throw new IllegalArgumentException(clss + " is not a mixin"); + nodeTypes.add(nodeType); + } + for (NodeType nodeType : nodeTypes) { + node.addMixin(nodeType.getName()); + } + // FIXME proper edition + node.getSession().save(); + } catch (RepositoryException e) { + throw new JcrException( + "Cannot add content classes " + contentClass + " to " + jcrPath + " in " + jcrWorkspace, e); + } + } + /* * ACCESS */ - boolean exists() { + protected boolean exists() { try { - return provider.getJcrSession(getSession(), jcrWorkspace).itemExists(jcrPath); + return getJcrSession().itemExists(jcrPath); } catch (RepositoryException e) { throw new JcrException("Cannot check whether " + jcrPath + " exists", e); } @@ -271,7 +319,7 @@ public class JcrContent extends AbstractContent { if ("".equals(jcrParentPath)) // JCR root node jcrParentPath = ContentUtils.SLASH_STRING; try { - return provider.getJcrSession(getSession(), jcrWorkspace).hasPermission(jcrParentPath, Session.ACTION_READ); + return getJcrSession().hasPermission(jcrParentPath, Session.ACTION_READ); } catch (RepositoryException e) { throw new JcrException("Cannot check whether parent " + jcrParentPath + " is accessible", e); } @@ -282,7 +330,9 @@ public class JcrContent extends AbstractContent { */ @SuppressWarnings("unchecked") public A adapt(Class clss) { - if (Source.class.isAssignableFrom(clss)) { + if (Node.class.isAssignableFrom(clss)) { + return (A) getJcrNode(); + } else if (Source.class.isAssignableFrom(clss)) { // try { PipedOutputStream out = new PipedOutputStream(); PipedInputStream in; @@ -295,7 +345,7 @@ public class JcrContent extends AbstractContent { ForkJoinPool.commonPool().execute(() -> { // try (PipedOutputStream out = new PipedOutputStream(in)) { try { - provider.getJcrSession(getSession(), jcrWorkspace).exportDocumentView(jcrPath, out, true, false); + getJcrSession().exportDocumentView(jcrPath, out, true, false); out.flush(); out.close(); } catch (IOException | RepositoryException e) { @@ -307,9 +357,9 @@ public class JcrContent extends AbstractContent { // } catch (IOException e) { // throw new RuntimeException("Cannot adapt " + JcrContent.this + " to " + clss, e); // } - } else - + } else { return super.adapt(clss); + } } @SuppressWarnings("unchecked") @@ -329,7 +379,7 @@ public class JcrContent extends AbstractContent { } @Override - public ContentProvider getProvider() { + public JcrContentProvider getProvider() { return provider; } @@ -345,16 +395,93 @@ public class JcrContent extends AbstractContent { /* * TYPING */ + + static Object convertSingleValue(Value value) throws JcrException, IllegalArgumentException { + try { + switch (value.getType()) { + case PropertyType.STRING: + return value.getString(); + case PropertyType.DOUBLE: + return (Double) value.getDouble(); + case PropertyType.LONG: + return (Long) value.getLong(); + case PropertyType.BOOLEAN: + return (Boolean) value.getBoolean(); + case PropertyType.DATE: + Calendar calendar = value.getDate(); + return calendar.toInstant(); + case PropertyType.BINARY: + throw new IllegalArgumentException("Binary is not supported as an attribute"); + default: + return value.getString(); + } + } catch (RepositoryException e) { + throw new JcrException("Cannot convert " + value + " to an object.", e); + } + } + + static Value convertSingleObject(ValueFactory factory, Object value) { + if (value instanceof String string) { + return factory.createValue(string); + } else if (value instanceof Double dbl) { + return factory.createValue(dbl); + } else if (value instanceof Float flt) { + return factory.createValue(flt); + } else if (value instanceof Long lng) { + return factory.createValue(lng); + } else if (value instanceof Integer intg) { + return factory.createValue(intg); + } else if (value instanceof Boolean bool) { + return factory.createValue(bool); + } else if (value instanceof Instant instant) { + GregorianCalendar calendar = new GregorianCalendar(); + calendar.setTime(Date.from(instant)); + return factory.createValue(calendar); + } else { + // TODO or use String by default? + throw new IllegalArgumentException("Unsupported value " + value.getClass()); + } + } + + @Override + public Class getType(QName key) { + Node node = getJcrNode(); + String p = NamespaceUtils.toFullyQualified(key); + try { + if (node.hasProperty(p)) { + Property property = node.getProperty(p); + return switch (property.getType()) { + case PropertyType.STRING: + case PropertyType.NAME: + case PropertyType.PATH: + case PropertyType.DECIMAL: + yield String.class; + case PropertyType.LONG: + yield Long.class; + case PropertyType.DOUBLE: + yield Double.class; + case PropertyType.BOOLEAN: + yield Boolean.class; + case PropertyType.DATE: + yield Instant.class; + case PropertyType.WEAKREFERENCE: + case PropertyType.REFERENCE: + yield UUID.class; + default: + yield Object.class; + }; + } else { + // TODO does it make sense? + return Object.class; + } + } catch (RepositoryException e) { + throw new JcrException("Cannot get type of property " + p + " of " + jcrPath + " in " + jcrWorkspace, e); + } + } + @Override public List getContentClasses() { try { -// Node node = getJcrNode(); -// List res = new ArrayList<>(); -// res.add(nodeTypeToQName(node.getPrimaryNodeType())); -// for (NodeType mixin : node.getMixinNodeTypes()) { -// res.add(nodeTypeToQName(mixin)); -// } -// return res; Node context = getJcrNode(); List res = new ArrayList<>(); @@ -375,15 +502,6 @@ public class JcrContent extends AbstractContent { secondaryTypes.add(nodeTypeToQName(superType)); } } -// // entity type -// if (context.isNodeType(EntityType.entity.get())) { -// if (context.hasProperty(EntityNames.ENTITY_TYPE)) { -// String entityTypeName = context.getProperty(EntityNames.ENTITY_TYPE).getString(); -// if (byType.containsKey(entityTypeName)) { -// types.add(entityTypeName); -// } -// } -// } res.addAll(secondaryTypes); return res; } catch (RepositoryException e) { @@ -397,9 +515,29 @@ public class JcrContent extends AbstractContent { // return QName.valueOf(name); } - @Override - public int getSiblingIndex() { - return Jcr.getIndex(getJcrNode()); + /* + * COMMON UTILITIES + */ + protected Session getJcrSession() { + return provider.getJcrSession(getSession(), jcrWorkspace); + } + + protected Node getJcrNode() { + try { + if (caching) { + synchronized (this) { + if (lastRetrievingThread != Thread.currentThread()) { + cachedNode = getJcrSession().getNode(jcrPath); + lastRetrievingThread = Thread.currentThread(); + } + return cachedNode; + } + } else { + return getJcrSession().getNode(jcrPath); + } + } catch (RepositoryException e) { + throw new JcrException("Cannot retrieve " + jcrPath + " from workspace " + jcrWorkspace, e); + } } /* @@ -414,10 +552,43 @@ public class JcrContent extends AbstractContent { if (contentSession == null) throw new IllegalArgumentException( "Cannot adapt " + node + " to content, because it was not loaded from a content session"); - return contentSession.get(ContentUtils.SLASH + CmsConstants.SYS_WORKSPACE + node.getPath()); + return contentSession.get(Content.ROOT_PATH + CmsConstants.SYS_WORKSPACE + node.getPath()); } catch (RepositoryException e) { throw new JcrException("Cannot adapt " + node + " to a content", e); } } + /* + * CONTENT ITERATOR + */ + + class JcrContentIterator implements Iterator { + private final NodeIterator nodeIterator; + // we keep track in order to be able to delete it + private JcrContent current = null; + + protected JcrContentIterator(NodeIterator nodeIterator) { + this.nodeIterator = nodeIterator; + } + + @Override + public boolean hasNext() { + return nodeIterator.hasNext(); + } + + @Override + public Content next() { + current = new JcrContent(getSession(), provider, jcrWorkspace, Jcr.getPath(nodeIterator.nextNode())); + return current; + } + + @Override + public void remove() { + if (current != null) { + Jcr.remove(current.getJcrNode()); + } + } + + } + }