import java.util.Date;\r
import java.util.GregorianCalendar;\r
\r
+import javax.jcr.RepositoryException;\r
import javax.jcr.Session;\r
+import javax.jcr.Workspace;\r
+import javax.jcr.query.QueryManager;\r
\r
import org.argeo.jcr.JcrUtils;\r
+import org.argeo.jcr.NodeMapper;\r
import org.argeo.jcr.NodeMapperProvider;\r
+import org.argeo.slc.SlcException;\r
import org.argeo.slc.runtime.SlcAgentDescriptor;\r
import org.argeo.slc.test.TestResult;\r
-\r
+import org.argeo.slc.test.TestRunDescriptor;\r
\r
public abstract class AbstractSlcJcrDao {\r
\r
private Session session;\r
\r
- //We inject the nodeMapperProvider that define a default node mapper as an\r
+ protected Workspace workspace;\r
+ protected QueryManager queryManager;\r
+ protected NodeMapper nodeMapper;\r
+\r
+ // We inject the nodeMapperProvider that define a default node mapper as an\r
// entry point of the NodeMapper\r
private NodeMapperProvider nodeMapperProvider;\r
\r
- \r
- \r
+ public void init() {\r
+ try {\r
+ workspace = getSession().getWorkspace();\r
+ queryManager = workspace.getQueryManager();\r
+ nodeMapper = getNodeMapperProvider().findNodeMapper(null);\r
+ } catch (RepositoryException e) {\r
+ throw new SlcException("Cannot initialize DAO", e);\r
+ }\r
+ }\r
+\r
public void setSession(Session session) {\r
this.session = session;\r
}\r
protected Session getSession() {\r
return session;\r
}\r
- \r
+\r
// IoC\r
public void setNodeMapperProvider(NodeMapperProvider nodeMapperProvider) {\r
this.nodeMapperProvider = nodeMapperProvider;\r
}\r
- \r
+\r
// TODO : define a strategy to define basePathes\r
protected String basePath(TestResult testResult) {\r
Calendar cal = new GregorianCalendar();\r
// cal.setTime(slcExecution.getStartDate());\r
return "/slc/testresult/" + JcrUtils.dateAsPath(cal) + "testresult";\r
}\r
- \r
+\r
protected String basePath(SlcAgentDescriptor slcAgentDescriptor) {\r
Calendar cal = new GregorianCalendar();\r
cal.setTime(new Date());\r
+ JcrUtils.hostAsPath(slcAgentDescriptor.getHost() + "/agent");\r
}\r
\r
- protected NodeMapperProvider getNodeMapperProvider(){\r
+ protected String basePath(TestRunDescriptor testRunDescriptor) {\r
+ Calendar cal = new GregorianCalendar();\r
+ cal.setTime(new Date());\r
+ // cal.setTime(slcExecution.getStartDate());\r
+ return "/slc/testruns/" + testRunDescriptor.getTestRunUuid()\r
+ + "/testrun";\r
+ }\r
+\r
+ protected NodeMapperProvider getNodeMapperProvider() {\r
return this.nodeMapperProvider;\r
}\r
\r
- \r
}\r
package org.argeo.slc.jcr.dao;\r
\r
import java.util.ArrayList;\r
-import java.util.Calendar;\r
-import java.util.Date;\r
-import java.util.GregorianCalendar;\r
import java.util.List;\r
\r
import javax.jcr.Node;\r
import javax.jcr.NodeIterator;\r
-import javax.jcr.RepositoryException;\r
-import javax.jcr.Workspace;\r
import javax.jcr.query.Query;\r
-import javax.jcr.query.QueryManager;\r
\r
import org.apache.commons.logging.Log;\r
import org.apache.commons.logging.LogFactory;\r
import org.argeo.jcr.JcrUtils;\r
-import org.argeo.jcr.NodeMapper;\r
import org.argeo.slc.SlcException;\r
import org.argeo.slc.dao.runtime.SlcAgentDescriptorDao;\r
import org.argeo.slc.runtime.SlcAgentDescriptor;\r
private final static Log log = LogFactory\r
.getLog(SlcAgentDescriptorDaoJcr.class);\r
\r
- private Workspace workspace;\r
- private QueryManager queryManager;\r
- private NodeMapper nodeMapper;\r
- \r
- public void init() {\r
- try {\r
- workspace = getSession().getWorkspace();\r
- queryManager = workspace.getQueryManager();\r
- nodeMapper = getNodeMapperProvider().findNodeMapper(null);\r
- } catch (RepositoryException e) {\r
- throw new SlcException("Cannot initialize DAO", e);\r
- }\r
- }\r
-\r
public void create(SlcAgentDescriptor slcAgentDescriptor) {\r
- if (log.isDebugEnabled())\r
- log.debug("in SlcAgentDescriptorDaoJcr.create");\r
try {\r
nodeMapper.save(getSession(), basePath(slcAgentDescriptor),\r
slcAgentDescriptor);\r
}\r
\r
public void delete(SlcAgentDescriptor slcAgentDescriptor) {\r
- if (log.isDebugEnabled())\r
- log.debug("slcAgentDescriptorDaoJcr.delete(slcAgentDescriptor)");\r
+ try {\r
+ String queryString = "//agent[@uuid='"\r
+ + slcAgentDescriptor.getUuid() + "']";\r
+ Query query = queryManager.createQuery(queryString, Query.XPATH);\r
+ Node node = JcrUtils.querySingleNode(query);\r
+ if (node != null) {\r
+ node.remove();\r
+ getSession().save();\r
+ } else\r
+ log.warn("No node found for agent descriptor: "\r
+ + slcAgentDescriptor);\r
+ } catch (Exception e) {\r
+ throw new SlcException("Cannot delete " + slcAgentDescriptor, e);\r
+ }\r
\r
}\r
\r
public void delete(String agentId) {\r
- if (log.isDebugEnabled())\r
- log.debug("slcAgentDescriptorDaoJcr.delete(agentID)");\r
try {\r
// TODO: optimize query\r
String queryString = "//agent[@uuid='" + agentId + "']";\r
}\r
\r
public List<SlcAgentDescriptor> listSlcAgentDescriptors() {\r
- if (log.isDebugEnabled())\r
- log.debug("slcAgentDescriptorDaoJcr.delete(agentID)");\r
-\r
try {\r
String queryString = "//agent";\r
Query query = queryManager.createQuery(queryString, Query.XPATH);\r
NodeIterator ni = query.execute().getNodes();\r
while (ni.hasNext()) {\r
Node curNode = (Node) ni.next();\r
- JcrUtils.debug(curNode);\r
+ // JcrUtils.debug(curNode);\r
listSad.add((SlcAgentDescriptor) nodeMapper.load(curNode));\r
}\r
\r
import javax.jcr.Node;
import javax.jcr.NodeIterator;
-import javax.jcr.RepositoryException;
-import javax.jcr.Workspace;
import javax.jcr.query.Query;
-import javax.jcr.query.QueryManager;
import javax.jcr.query.QueryResult;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
import org.argeo.jcr.JcrUtils;
-import org.argeo.jcr.NodeMapper;
-import org.argeo.jcr.NodeMapperProvider;
import org.argeo.slc.SlcException;
import org.argeo.slc.dao.process.SlcExecutionDao;
import org.argeo.slc.process.SlcExecution;
import org.argeo.slc.process.SlcExecutionStep;
-public class SlcExecutionDaoJcr extends AbstractSlcJcrDao implements SlcExecutionDao {
- private final static Log log = LogFactory.getLog(SlcExecutionDaoJcr.class);
- private Workspace workspace;
- private QueryManager queryManager;
-
- private NodeMapper nodeMapper;
- private NodeMapperProvider nodeMapperProvider;
-
- public void init() {
- try {
- workspace = getSession().getWorkspace();
- queryManager = workspace.getQueryManager();
- nodeMapper = nodeMapperProvider.findNodeMapper(null);
-
- } catch (RepositoryException e) {
- throw new SlcException("Cannot initialize DAO", e);
- }
- }
+public class SlcExecutionDaoJcr extends AbstractSlcJcrDao implements
+ SlcExecutionDao {
+ // private final static Log log =
+ // LogFactory.getLog(SlcExecutionDaoJcr.class);
public void addSteps(String slcExecutionId,
List<SlcExecutionStep> additionalSteps) {
}
public void create(SlcExecution slcExecution) {
- if (log.isDebugEnabled())
- log.debug("create");
-
try {
- nodeMapper.save(getSession(), basePath(slcExecution),
- slcExecution);
+ nodeMapper.save(getSession(), basePath(slcExecution), slcExecution);
getSession().save();
} catch (Exception e) {
- throw new SlcException("Cannot create slcExecution" + slcExecution, e);
+ throw new SlcException("Cannot create slcExecution" + slcExecution,
+ e);
}
}
cal.setTime(new Date());
// cal.setTime(slcExecution.getStartDate());
return "/slc/processes/" + JcrUtils.hostAsPath(slcExecution.getHost())
- + '/' + JcrUtils.dateAsPath(cal) + "process";
+ + '/' + JcrUtils.dateAsPath(cal) + "process";
}
-
public SlcExecution getSlcExecution(String uuid) {
- if (log.isDebugEnabled())
- log.debug("getSlcExecution");
-
try {
// TODO: optimize query
String queryString = "//process[@uuid='" + uuid + "']";
}
public List<SlcExecution> listSlcExecutions() {
- if (log.isDebugEnabled())
- log.debug("listSlcExecutions");
-
List<SlcExecution> res = new ArrayList<SlcExecution>();
// TODO: optimize query
String queryString = "//process";
}
public void update(SlcExecution slcExecution) {
- if (log.isDebugEnabled())
- log.debug("update");
-
// TODO: optimize query
String queryString = "//process[@uuid='" + slcExecution.getUuid()
+ "']";
}
}
- //IoC
- public void setNodeMapperProvider(NodeMapperProvider nodeMapperProvider) {
- this.nodeMapperProvider = nodeMapperProvider;
- }
}
--- /dev/null
+package org.argeo.slc.jcr.dao;
+
+import javax.jcr.Node;
+import javax.jcr.query.Query;
+
+import org.argeo.jcr.JcrUtils;
+import org.argeo.slc.SlcException;
+import org.argeo.slc.dao.test.TestRunDescriptorDao;
+import org.argeo.slc.test.TestRunDescriptor;
+
+public class TestRunDescriptorDaoJcr extends AbstractSlcJcrDao implements
+ TestRunDescriptorDao {
+
+ public TestRunDescriptor getTestRunDescriptor(String id) {
+ try {
+ // TODO: optimize query
+ String queryString = "//testrun[@testRunUuid='" + id + "']";
+ Query query = queryManager.createQuery(queryString, Query.XPATH);
+ Node node = JcrUtils.querySingleNode(query);
+ if (node == null)
+ return null;
+ return (TestRunDescriptor) nodeMapper.load(node);
+ } catch (Exception e) {
+ throw new SlcException("Cannot load test run descriptor" + id, e);
+ }
+ }
+
+ public void saveOrUpdate(TestRunDescriptor testRunDescriptor) {
+ try {
+ nodeMapper.save(getSession(), basePath(testRunDescriptor),
+ testRunDescriptor);
+ getSession().save();
+ } catch (Exception e) {
+ throw new SlcException("Cannot import " + testRunDescriptor, e);
+ }
+ }
+
+}
package org.argeo.slc.jcr.dao;\r
\r
+import java.util.ArrayList;\r
+import java.util.HashMap;\r
import java.util.List;\r
import java.util.Map;\r
import java.util.SortedSet;\r
+import java.util.TreeSet;\r
\r
import javax.jcr.Node;\r
import javax.jcr.NodeIterator;\r
-import javax.jcr.RepositoryException;\r
-import javax.jcr.Workspace;\r
import javax.jcr.query.Query;\r
-import javax.jcr.query.QueryManager;\r
\r
import org.apache.commons.logging.Log;\r
import org.apache.commons.logging.LogFactory;\r
import org.argeo.jcr.JcrUtils;\r
-import org.argeo.jcr.NodeMapper;\r
import org.argeo.slc.SlcException;\r
import org.argeo.slc.core.test.tree.ResultAttributes;\r
import org.argeo.slc.core.test.tree.TreeTestResult;\r
private final static Log log = LogFactory\r
.getLog(TreeTestResultCollectionDaoJcr.class);\r
\r
- private Workspace workspace;\r
- private QueryManager queryManager;\r
- private NodeMapper nodeMapper;\r
-\r
- public void init() {\r
- try {\r
- workspace = getSession().getWorkspace();\r
- queryManager = workspace.getQueryManager();\r
- nodeMapper = getNodeMapperProvider().findNodeMapper(null);\r
- } catch (RepositoryException e) {\r
- throw new SlcException("Cannot initialize DAO", e);\r
- }\r
- }\r
-\r
public void create(TreeTestResultCollection ttrCollection) {\r
try {\r
Node curNode;\r
}\r
\r
public TreeTestResultCollection getTestResultCollection(String id) {\r
- try {\r
- TreeTestResultCollection res = new TreeTestResultCollection();\r
- res.setId(id);\r
+ TreeTestResultCollection res = new TreeTestResultCollection();\r
+ res.setId(id);\r
\r
- String queryString = "//*[@" + ttrColProp + "='" + id + "']";\r
- Query query = queryManager.createQuery(queryString, Query.XPATH);\r
- log.debug("retrieving all nodes of a col - " + queryString);\r
- int i = 0;\r
- NodeIterator ni = query.execute().getNodes();\r
- while (ni.hasNext()) {\r
- i++;\r
- res.getResults().add(\r
- (TreeTestResult) nodeMapper.load(ni.nextNode()));\r
- }\r
- log.debug(i + " nodes found");\r
- return res;\r
- } catch (RepositoryException e) {\r
- throw new SlcException(\r
- "Cannot get TreeTestResultCollection for id " + id, e);\r
+ // String queryString = "//*[@" + ttrColProp + "='" + id + "']";\r
+ // Query query = queryManager.createQuery(queryString, Query.XPATH);\r
+ // log.debug("retrieving all nodes of a col - " + queryString);\r
+ int i = 0;\r
+ NodeIterator ni = resultNodesInCollection(id);\r
+ while (ni.hasNext()) {\r
+ i++;\r
+ res.getResults().add(\r
+ (TreeTestResult) nodeMapper.load(ni.nextNode()));\r
}\r
+ // log.debug(i + " nodes found");\r
+ return res;\r
}\r
\r
/**\r
nodeMapper.update(curNode, ttr);\r
log.debug("Node updated");\r
}\r
- log.debug("-----------------------------------------------------------------");\r
+ log\r
+ .debug("-----------------------------------------------------------------");\r
curNode.setProperty(ttrColProp, colId);\r
JcrUtils.debug(curNode.getSession().getRootNode());\r
}\r
\r
public void delete(TreeTestResultCollection ttrCollection) {\r
try {\r
+ // FIXME: should not delete sub nodes\r
Node curNode;\r
String colId = ttrCollection.getId();\r
- String queryString = "//*[@" + ttrColProp + "='" + colId + "']";\r
- Query query = queryManager.createQuery(queryString, Query.XPATH);\r
- NodeIterator ni = query.execute().getNodes();\r
+ NodeIterator ni = resultNodesInCollection(colId);\r
while (ni.hasNext()) {\r
curNode = ni.nextNode();\r
curNode.remove();\r
}\r
}\r
\r
- // FIXME Implement this method\r
public SortedSet<TreeTestResultCollection> listCollections() {\r
- // return new TreeSet<TreeTestResultCollection>(getHibernateTemplate()\r
- // .find("from TreeTestResultCollection"));\r
- return null;\r
+ // FIXME: optimize\r
+ Map<String, TreeTestResultCollection> lst = new HashMap<String, TreeTestResultCollection>();\r
+ NodeIterator nodeIterator = query("//testresult");\r
+ while (nodeIterator.hasNext()) {\r
+ Node node = nodeIterator.nextNode();\r
+ String colId = property(node, ttrColProp);\r
+ if (colId != null) {\r
+ if (!lst.containsKey(colId))\r
+ lst.put(colId, new TreeTestResultCollection(colId));\r
+ TreeTestResultCollection ttrc = lst.get(colId);\r
+ ttrc.getResults().add((TreeTestResult) nodeMapper.load(node));\r
+ }\r
+ }\r
+ return new TreeSet<TreeTestResultCollection>(lst.values());\r
}\r
\r
public void addResultToCollection(final TreeTestResultCollection ttrc,\r
\r
// FIXME specify and implement this method\r
public List<ResultAttributes> listResultAttributes(String collectionId) {\r
- /**\r
- * List<ResultAttributes> list; if (collectionId == null) list =\r
- * getHibernateTemplate().find(\r
- * "select new org.argeo.slc.core.test.tree.ResultAttributes(ttr)" +\r
- * " from TreeTestResult ttr"); else list = getHibernateTemplate()\r
- * .find(\r
- * "select new org.argeo.slc.core.test.tree.ResultAttributes(ttr) " +\r
- * " from TreeTestResult ttr, TreeTestResultCollection ttrc " +\r
- * " where ttr in elements(ttrc.results) and ttrc.id=?", collectionId);\r
- * \r
- * return list;\r
- */\r
- return null;\r
- }\r
+ // FIXME: optimize\r
+ List<ResultAttributes> list = new ArrayList<ResultAttributes>();\r
+ if (collectionId == null) {\r
+ List<TreeTestResult> results = asTreeTestResultList(resultNodes(\r
+ null, null));\r
\r
- // FIXME specify and implement this method\r
+ for (TreeTestResult ttr : results) {\r
+ list.add(new ResultAttributes(ttr));\r
+ }\r
+ } else {\r
+ NodeIterator nodeIterator = resultNodesInCollection(collectionId);\r
+ while (nodeIterator.hasNext()) {\r
+ list.add(new ResultAttributes((TreeTestResult) nodeMapper\r
+ .load(nodeIterator.nextNode())));\r
+ }\r
+ }\r
+\r
+ return list;\r
+ // throw new UnsupportedOperationException();\r
+ // List<ResultAttributes> list;\r
+ // if (collectionId == null)\r
+ // list = getHibernateTemplate().find(\r
+ // "select new org.argeo.slc.core.test.tree.ResultAttributes(ttr)"\r
+ // + " from TreeTestResult ttr");\r
+ // else\r
+ // list = getHibernateTemplate()\r
+ // .find(\r
+ // "select new org.argeo.slc.core.test.tree.ResultAttributes(ttr) "\r
+ // + " from TreeTestResult ttr, TreeTestResultCollection ttrc "\r
+ // + " where ttr in elements(ttrc.results) and ttrc.id=?",\r
+ // collectionId);\r
+ //\r
+ // return list;\r
+ }\r
\r
public List<TreeTestResult> listResults(String collectionId,\r
Map<String, String> attributes) {\r
- /**\r
- * List<TreeTestResult> list;\r
- * \r
- * if (collectionId == null) { if (attributes == null ||\r
- * attributes.size() == 0) list =\r
- * getHibernateTemplate().find("from TreeTestResult"); else if\r
- * (attributes.size() == 1) { Map.Entry<String, String> entry =\r
- * attributes.entrySet() .iterator().next(); Object[] args = {\r
- * entry.getKey(), entry.getValue() }; list =\r
- * getHibernateTemplate().find( "select ttr from TreeTestResult ttr" +\r
- * " where attributes[?]=?", args); } else { throw new SlcException(\r
- * "Multiple attributes filter are currently not supported."); } } else\r
- * { if (attributes == null || attributes.size() == 0) list =\r
- * getHibernateTemplate() .find( "select ttr " +\r
- * " from TreeTestResult ttr, TreeTestResultCollection ttrc " +\r
- * " where ttr in elements(ttrc.results) and ttrc.id=?", collectionId);\r
- * else if (attributes.size() == 1) { Map.Entry<String, String> entry =\r
- * attributes.entrySet() .iterator().next(); Object[] args = {\r
- * collectionId, entry.getKey(), entry.getValue() }; list =\r
- * getHibernateTemplate() .find(\r
- * "select ttr from TreeTestResult ttr, TreeTestResultCollection ttrc "\r
- * + " where ttr in elements(ttrc.results) and ttrc.id=?" +\r
- * " and attributes[?]=?", args); } else { throw new SlcException(\r
- * "Multiple attributes filter are currently not supported."); } }\r
- * return list;\r
- */\r
- return null;\r
+ List<TreeTestResult> list;\r
+\r
+ if (collectionId == null) {\r
+ if (attributes == null || attributes.size() == 0)\r
+ list = asTreeTestResultList(resultNodes(null, null));\r
+ else if (attributes.size() == 1) {\r
+ Map.Entry<String, String> entry = attributes.entrySet()\r
+ .iterator().next();\r
+ list = asTreeTestResultList(resultNodes(entry.getKey(), entry\r
+ .getValue()));\r
+ } else {\r
+ throw new SlcException(\r
+ "Multiple attributes filter are currently not supported.");\r
+ }\r
+ } else {\r
+ if (attributes == null || attributes.size() == 0)\r
+ list = asTreeTestResultList(resultNodesInCollection(collectionId));\r
+ else if (attributes.size() == 1) {\r
+ Map.Entry<String, String> entry = attributes.entrySet()\r
+ .iterator().next();\r
+ list = asTreeTestResultList(resultNodesInCollection(\r
+ collectionId, entry.getKey(), entry.getValue()));\r
+ } else {\r
+ throw new SlcException(\r
+ "Multiple attributes filter are currently not supported.");\r
+ }\r
+ }\r
+ return list;\r
+ }\r
+\r
+ // UTILITIES\r
+\r
+ protected NodeIterator resultNodesInCollection(String collectionId,\r
+ String attributeKey, String attributeValue) {\r
+ String queryString = "//testresult[@" + ttrColProp + "='"\r
+ + collectionId + "' and @" + attributeKey + "='"\r
+ + attributeValue + "']";\r
+ return query(queryString);\r
+ }\r
+\r
+ protected NodeIterator resultNodesInCollection(String collectionId) {\r
+ String queryString = "//testresult[@" + ttrColProp + "='"\r
+ + collectionId + "']";\r
+ return query(queryString);\r
+ }\r
+\r
+ protected NodeIterator resultNodes(String attributeKey,\r
+ String attributeValue) {\r
+ String queryString;\r
+ if (attributeKey != null)\r
+ queryString = "//testResult[@" + attributeKey + "='"\r
+ + attributeValue + "']";\r
+ else\r
+ queryString = "//testResult";\r
+ return query(queryString);\r
+ }\r
+\r
+ protected List<TreeTestResult> asTreeTestResultList(\r
+ NodeIterator nodeIterator) {\r
+ List<TreeTestResult> lst = new ArrayList<TreeTestResult>();\r
+ while (nodeIterator.hasNext()) {\r
+ lst.add((TreeTestResult) nodeMapper.load(nodeIterator.nextNode()));\r
+ }\r
+ return lst;\r
+ }\r
+\r
+ private NodeIterator query(String query) {\r
+ try {\r
+ if (log.isDebugEnabled())\r
+ log.debug("Retrieve nodes from query: " + query);\r
+ Query q = queryManager.createQuery(query, Query.XPATH);\r
+ return q.execute().getNodes();\r
+ } catch (Exception e) {\r
+ throw new SlcException("Cannot load nodes from query: " + query);\r
+ }\r
}\r
+\r
+ private String property(Node node, String key) {\r
+ try {\r
+ return node.getProperty(key).getString();\r
+ } catch (Exception e) {\r
+ log.warn("Cannot retrieve property " + key + " of node " + node, e);\r
+ return null;\r
+ }\r
+ }\r
+\r
}\r
\r
import javax.jcr.Node;\r
import javax.jcr.NodeIterator;\r
-import javax.jcr.RepositoryException;\r
import javax.jcr.Session;\r
-import javax.jcr.Workspace;\r
import javax.jcr.query.Query;\r
import javax.jcr.query.QueryManager;\r
import javax.jcr.query.QueryResult;\r
import org.apache.commons.logging.Log;\r
import org.apache.commons.logging.LogFactory;\r
import org.argeo.jcr.JcrUtils;\r
-import org.argeo.jcr.NodeMapper;\r
import org.argeo.slc.SlcException;\r
import org.argeo.slc.core.attachment.SimpleAttachment;\r
import org.argeo.slc.core.structure.tree.TreeSPath;\r
private final static Log log = LogFactory\r
.getLog(TreeTestResultDaoJcr.class);\r
\r
- private Workspace workspace;\r
- private QueryManager queryManager;\r
- private NodeMapper nodeMapper;\r
-\r
- \r
- public TreeTestResultDaoJcr() {\r
- }\r
-\r
- public void init() {\r
- try {\r
- workspace = getSession().getWorkspace();\r
- queryManager = workspace.getQueryManager();\r
- nodeMapper = getNodeMapperProvider().findNodeMapper(null);\r
- } catch (RepositoryException e) {\r
- throw new SlcException("Cannot initialize DAO", e);\r
- }\r
- }\r
-\r
- public void create(TestResult testResult) {\r
+ public synchronized void create(TestResult testResult) {\r
try {\r
nodeMapper.save(getSession(), basePath(testResult), testResult);\r
getSession().save();\r
- //JcrUtils.debug(getSession().getRootNode());\r
} catch (Exception e) {\r
throw new SlcException("Cannot create testResult " + testResult, e);\r
}\r
}\r
\r
- public void update(TestResult testResult) {\r
+ public synchronized void update(TestResult testResult) {\r
try {\r
nodeMapper.save(getSession(), basePath(testResult), testResult);\r
getSession().save();\r
}\r
}\r
\r
- public void close(final String testResultId, final Date closeDate) {\r
+ public synchronized void close(final String testResultId,\r
+ final Date closeDate) {\r
try {\r
// TODO: optimize query\r
- String queryString = "//testresult[@uiid='" + testResultId + "']";\r
+ String queryString = "//testresult[@uuid='" + testResultId + "']";\r
Query query = queryManager.createQuery(queryString, Query.XPATH);\r
Node resNode = JcrUtils.querySingleNode(query);\r
Calendar cal = new GregorianCalendar();\r
cal.setTime(closeDate);\r
- resNode.setProperty("closeDate", cal);\r
+ if (resNode != null)\r
+ resNode.setProperty("closeDate", cal);\r
+ else if (log.isDebugEnabled())\r
+ log.debug("Cannot close because a node for test result # "\r
+ + testResultId + " was not found");\r
getSession().save();\r
} catch (Exception e) {\r
throw new SlcException("Cannot close TestResult " + testResultId, e);\r
*/\r
// TODO do we load objects, do treatment and persist them or do we work\r
// directly in JCR\r
- public void addResultPart(final String testResultId, final TreeSPath path,\r
- final SimpleResultPart resultPart,\r
+ public synchronized void addResultPart(final String testResultId,\r
+ final TreeSPath path, final SimpleResultPart resultPart,\r
final Map<TreeSPath, StructureElement> relatedElements) {\r
\r
try {\r
// TODO: optimize query\r
- String queryString = "//*[@uuid='" + testResultId + "']";\r
+ String queryString = "//testresult[@uuid='" + testResultId + "']";\r
Query query = queryManager.createQuery(queryString, Query.XPATH);\r
Node resNode = JcrUtils.querySingleNode(query);\r
\r
Map<String, String> tags = relatedElements.get(key)\r
.getTags();\r
for (String tag : tags.keySet()) {\r
- curNode.setProperty(tag, tags.get(tag));\r
+ String cleanTag = JcrUtils\r
+ .removeForbiddenCharacters(tag);\r
+ if (!cleanTag.equals(tag))\r
+ log.warn("Tag '" + tag + "' persisted as '"\r
+ + cleanTag + "'");\r
+ curNode.setProperty(cleanTag, tags.get(tag));\r
}\r
\r
// We set the class in order to be able to retrieve\r
}\r
}\r
\r
- public void addAttachment(final String testResultId,\r
+ public synchronized void addAttachment(final String testResultId,\r
final SimpleAttachment attachment) {\r
\r
try {\r
}\r
}\r
\r
- public void updateAttributes(final String testResultId,\r
+ public synchronized void updateAttributes(final String testResultId,\r
final Map<String, String> attributes) {\r
try {\r
String queryString = "//testresult[@uuid='" + testResultId + "']";\r
Query query = queryManager.createQuery(queryString, Query.XPATH);\r
Node node = JcrUtils.querySingleNode(query);\r
\r
- for (String key: attributes.keySet()){\r
- node.setProperty(key, attributes.get(key));\r
+ for (String key : attributes.keySet()) {\r
+ node.setProperty(key, attributes.get(key));\r
}\r
getSession().save();\r
} catch (Exception e) {\r
- throw new SlcException("Cannot update Attributes on TestResult with ID "\r
- + testResultId , e);\r
+ throw new SlcException(\r
+ "Cannot update Attributes on TestResult with ID "\r
+ + testResultId, e);\r
}\r
}\r
\r
- \r
- \r
-\r
}\r
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;
// We add the tags
Map<String, String> tags = elements.get(key).getTags();
for (String tag : tags.keySet()) {
- childNode.setProperty(tag, tags.get(tag));
+ // remove forbidden characters
+ String cleanTag = JcrUtils.removeForbiddenCharacters(tag);
+ if (!cleanTag.equals(tag))
+ log.warn("Tag '" + tag + "' persisted as '" + cleanTag
+ + "'");
+ childNode.setProperty(cleanTag, tags.get(tag));
}
// We set the class in order to be able to retrieve
Node listNode;
int i;
for (i = 0; i < list.size(); i++) {
- TestResultPart trp = list.get(i);
+ // TestResultPart trp = list.get(i);
// FIXME : ResultParts are systematicaly added.
// There no check to see if already exists.
listNode = childNode.addNode("resultpart");
if (log.isTraceEnabled())
log.debug("Map node " + node.getPath() + " to bean " + clssName);
-
- // It's a very specific implementation,
+ // It's a very specific implementation,
// We don't need to use a bean wrapper.
TreeTestResult ttr = new TreeTestResult();
props: while (propIt.hasNext()) {
Property prop = propIt.nextProperty();
- //TODO Define a rule to generalize it (Namespace ??)
+ // TODO Define a rule to generalize it (Namespace ??)
// Get rid of specific case. mainly uuid
if ("uuid".equals(prop.getName())
|| prop.getName().equals(getClassProperty())
ttr.setAttachments(attachments);
}
- // STRUCTURED ELEMENTS
-
+ // STRUCTURED ELEMENTS
+
String basePath = node.getPath();
SortedMap<TreeSPath, PartSubList> resultParts = new TreeMap<TreeSPath, PartSubList>();
SortedMap<TreeSPath, StructureElement> elements = new TreeMap<TreeSPath, StructureElement>();
PropertyIterator tagIt = curNode.getProperties();
tags: while (tagIt.hasNext()) {
Property prop = tagIt.nextProperty();
- log.debug("Handling property named : " + prop.getName());
+ //log.debug("Handling property named : " + prop.getName());
- //TODO Define a rule to generalize it
+ // TODO Define a rule to generalize it
// Specific case. mainly uuid
if ("uuid".equals(prop.getName())
|| prop.getName().equals(getClassProperty())
ttr.setElements(elements);
// RESULTPARTS
-
+
// We have to had the uuid of the current node to be sure that we are in
// its sub tree
queryString = "//testresult[@uuid='" + uuid + "']";
projects / gpl / argeo-slc.git / commitdiff