X-Git-Url: http://git.argeo.org/?a=blobdiff_plain;f=runtime%2Forg.argeo.slc.support.jcr%2Fsrc%2Fmain%2Fjava%2Forg%2Fargeo%2Fslc%2Fjcr%2Fexecution%2FJcrResultListener.java;h=12ade515dcc7d772f5c49671a029747bb5b6ef69;hb=4444b88528fd1ba4de62d47bf885bbe9403d2216;hp=8cd72efc7bbd42436a24ca97af8556571bf2b27d;hpb=a0e8f9b4d92028975baaba0317899536045804c8;p=gpl%2Fargeo-slc.git diff --git a/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/execution/JcrResultListener.java b/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/execution/JcrResultListener.java index 8cd72efc7..12ade515d 100644 --- a/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/execution/JcrResultListener.java +++ b/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/execution/JcrResultListener.java @@ -1,3 +1,18 @@ +/* + * Copyright (C) 2007-2012 Mathieu Baudier + * + * Licensed 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.argeo.slc.jcr.execution; import java.util.Collections; @@ -6,16 +21,23 @@ import java.util.HashMap; import java.util.Map; import javax.jcr.Node; +import javax.jcr.NodeIterator; import javax.jcr.Property; +import javax.jcr.PropertyIterator; import javax.jcr.RepositoryException; import javax.jcr.Session; import javax.jcr.query.Query; +import javax.jcr.query.QueryManager; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.argeo.jcr.JcrUtils; +import org.argeo.slc.SlcException; import org.argeo.slc.core.attachment.Attachment; +import org.argeo.slc.core.structure.SimpleSElement; import org.argeo.slc.core.structure.tree.TreeSPath; +import org.argeo.slc.core.test.SimpleResultPart; +import org.argeo.slc.core.test.tree.PartSubList; import org.argeo.slc.core.test.tree.TreeTestResult; import org.argeo.slc.core.test.tree.TreeTestResultListener; import org.argeo.slc.jcr.SlcJcrUtils; @@ -24,7 +46,11 @@ import org.argeo.slc.jcr.SlcTypes; import org.argeo.slc.test.TestResultPart; import org.argeo.slc.test.TestStatus; -/** Persists results in JCR */ +/** + * Persists results in JCR by listening to {@link TreeTestResult}. This is to + * facilitate transition from legacy approaches and should not be used in new + * implementations. + */ public class JcrResultListener implements TreeTestResultListener, SlcNames { private final static Log log = LogFactory.getLog(JcrResultListener.class); @@ -61,12 +87,25 @@ public class JcrResultListener implements TreeTestResultListener, SlcNames { // session.save(); } // create part node - // TODO find a better name - String partNodeName = Long.toString(System.currentTimeMillis()); + SimpleSElement element = null; + if (testResult.getElements().containsKey(currentPath)) { + element = (SimpleSElement) testResult.getElements().get( + currentPath); + } + + String elementLabel = element != null && element.getLabel() != null + && !element.getLabel().trim().equals("") ? element + .getLabel() : null; + String partNodeName = elementLabel != null ? JcrUtils + .replaceInvalidChars(elementLabel, '_') : Long + .toString(System.currentTimeMillis()); + Node resultPartNode = partParentNode.addNode(partNodeName, SlcTypes.SLC_CHECK); resultPartNode.setProperty(SLC_SUCCESS, testResultPart.getStatus() == TestStatus.PASSED); + if (elementLabel != null) + resultPartNode.setProperty(Property.JCR_TITLE, elementLabel); if (testResultPart.getMessage() != null) resultPartNode.setProperty(SLC_MESSAGE, testResultPart.getMessage()); @@ -74,9 +113,28 @@ public class JcrResultListener implements TreeTestResultListener, SlcNames { resultPartNode.setProperty(SLC_ERROR_MESSAGE, testResultPart.getExceptionMessage()); // JcrUtils.debug(resultPartNode); - + JcrUtils.updateLastModified(resultNode); - + + if (element != null) { + element = (SimpleSElement) testResult.getElements().get( + currentPath); + if (log.isTraceEnabled()) + log.trace(" Path= " + currentPath + ", part=" + + testResultPart.getMessage()); + for (Map.Entry tag : element.getTags() + .entrySet()) { + String tagNodeName = JcrUtils.replaceInvalidChars( + tag.getKey(), '_'); + // log.debug("key=" + tag.getKey() + ", tagNodeName=" + // + tagNodeName); + Node tagNode = resultPartNode.addNode(tagNodeName, + SlcTypes.SLC_PROPERTY); + tagNode.setProperty(SLC_NAME, tag.getKey()); + tagNode.setProperty(SLC_VALUE, tag.getValue()); + } + } + session.save(); } catch (RepositoryException e) { JcrUtils.discardQuietly(session); @@ -110,7 +168,7 @@ public class JcrResultListener implements TreeTestResultListener, SlcNames { protected Node createResultNode(TreeTestResult testResult) throws RepositoryException { String uuid = testResult.getUuid(); - String path = SlcJcrUtils.createResultPath(uuid); + String path = SlcJcrUtils.createResultPath(session.getUserID(), uuid); Node resultNode = JcrUtils.mkdirs(session, path, SlcTypes.SLC_RESULT); resultNode.setProperty(SLC_UUID, uuid); for (Map.Entry entry : testResult.getAttributes() @@ -135,6 +193,9 @@ public class JcrResultListener implements TreeTestResultListener, SlcNames { uuidToIdentifier.remove(uuid); session.save(); + + if (log.isDebugEnabled()) + log.debug("Closed test result " + uuid); } catch (RepositoryException e) { JcrUtils.discardQuietly(session); log.error("Cannot close result " + testResult, e); @@ -151,4 +212,75 @@ public class JcrResultListener implements TreeTestResultListener, SlcNames { this.session = session; } + /** + * Creates and populates a {@link TreeTestResult} from the related result + * node. Meant to simplify migration of legacy applications. This is no + * stable API. + */ + public static TreeTestResult nodeToTreeTestResult(Node resultNode) { + try { + String resultPath = resultNode.getPath(); + TreeTestResult ttr = new TreeTestResult(); + // base properties + ttr.setUuid(resultNode.getProperty(SLC_UUID).getString()); + if (resultNode.hasProperty(SLC_COMPLETED)) + ttr.setCloseDate(resultNode.getProperty(SLC_COMPLETED) + .getDate().getTime()); + // attributes + for (PropertyIterator pit = resultNode.getProperties(); pit + .hasNext();) { + Property p = pit.nextProperty(); + if (p.getName().indexOf(':') < 0) { + ttr.getAttributes().put(p.getName(), p.getString()); + } + } + + QueryManager qm = resultNode.getSession().getWorkspace() + .getQueryManager(); + String statement = "SELECT * FROM [" + SlcTypes.SLC_CHECK + + "] WHERE ISDESCENDANTNODE(['" + resultPath + "'])"; + NodeIterator nit = qm.createQuery(statement, Query.JCR_SQL2) + .execute().getNodes(); + while (nit.hasNext()) { + Node checkNode = nit.nextNode(); + String relPath = checkNode.getPath().substring( + resultPath.length()); + TreeSPath tsp = new TreeSPath(relPath); + + // result part + SimpleResultPart srp = new SimpleResultPart(); + if (checkNode.getProperty(SLC_SUCCESS).getBoolean()) + srp.setStatus(TestStatus.PASSED); + else if (checkNode.hasProperty(SLC_ERROR_MESSAGE)) + srp.setStatus(TestStatus.ERROR); + else + srp.setStatus(TestStatus.FAILED); + if (checkNode.hasProperty(SLC_MESSAGE)) + srp.setMessage(checkNode.getProperty(SLC_MESSAGE) + .getString()); + if (!ttr.getResultParts().containsKey(tsp)) + ttr.getResultParts().put(tsp, new PartSubList()); + ttr.getResultParts().get(tsp).getParts().add(srp); + + // element + SimpleSElement elem = new SimpleSElement(); + if (checkNode.hasProperty(Property.JCR_TITLE)) + elem.setLabel(checkNode.getProperty(Property.JCR_TITLE) + .getString()); + else + elem.setLabel("");// some legacy code expect it to be set + for (NodeIterator tagIt = checkNode.getNodes(); tagIt.hasNext();) { + Node tagNode = tagIt.nextNode(); + elem.getTags().put( + tagNode.getProperty(SLC_NAME).getString(), + tagNode.getProperty(SLC_VALUE).getString()); + } + ttr.getElements().put(tsp, elem); + } + return ttr; + } catch (RepositoryException e) { + throw new SlcException("Cannot generate tree test result from " + + resultNode, e); + } + } }