AnnotationManagerN4J: src/main/java/de/mpiwg/itgroup/annotations/neo4j/AnnotationStore.java comparison

comparison src/main/java/de/mpiwg/itgroup/annotations/neo4j/AnnotationStore.java @ 68:39bc52f9b102

(hopefully) fixed issues with neo4j 2.0 transactions.

author	casties
date	Sat, 22 Feb 2014 07:12:37 -0800
parents	875a97f8b8da
children	2b1e6df5e21a

comparison

equal deleted inserted replaced

-:875a97f8b8da
+:39bc52f9b102
 public AnnotationStore(GraphDatabaseService graphDb) {
 super();
 this.graphDb = graphDb;
 nodeIndexes = new ArrayList<Index<Node>>(5);
 // List.set(enum.ordinal(), val) seems not to work.
-try ( Transaction tx = graphDb.beginTx() ) {
+try (Transaction tx = graphDb.beginTx()) {
 nodeIndexes.add(NodeTypes.ANNOTATION.ordinal(), graphDb.index().forNodes("annotations"));
 nodeIndexes.add(NodeTypes.PERSON.ordinal(), graphDb.index().forNodes("persons"));
 nodeIndexes.add(NodeTypes.TARGET.ordinal(), graphDb.index().forNodes("targets"));
 nodeIndexes.add(NodeTypes.GROUP.ordinal(), graphDb.index().forNodes("groups"));
 nodeIndexes.add(NodeTypes.TAG.ordinal(), graphDb.index().forNodes("tags"));
 * @param value
 * @param type
 * @return
 */
 public Node getNodeFromIndex(String key, String value, NodeTypes type) {
-if (key == null || value == null) return null;
+if (key == null || value == null)
+return null;
 Node node = null;
 try (Transaction tx = graphDb.beginTx()) {
 node = getNodeIndex(type).get(key, value).getSingle();
 tx.success();
 }
 IndexHits<Node> actorNodes = idx.query(key, query);
 for (Node actorNode : actorNodes) {
 Actor actor = createActorFromNode(actorNode);
 actors.add((T) actor);
 }
 tx.success();
 }
 return actors;
 }
 /**
 * @param group
 * @return
 */
 public boolean isPersonInGroup(Person person, Group group) {
 Node pn = getPersonNodeByUri(person.getUriString());
-if (pn == null) return false;
+if (pn == null)
+return false;
 // optimized version of getGroupsForPersonNode
 try (Transaction tx = graphDb.beginTx()) {
 Iterable<Relationship> rels = pn.getRelationships(RelationTypes.MEMBER_OF);
 for (Relationship rel : rels) {
 Node gn = rel.getEndNode();
-if (gn.getProperty("uri", "").equals(group.getUriString()) || gn.getProperty("id", "").equals(group.getId())) {
+if (gn.getProperty("uri", "").equals(group.getUriString())
-tx.success();
+|| gn.getProperty("id", "").equals(group.getId())) {
-return true;
+tx.success();
-}
+return true;
 }
-tx.success();
+}
+tx.success();
 }
 return false;
 }
 /**
 Node pn = getActorNode(member);
 Iterable<Relationship> rels = gn.getRelationships(RelationTypes.MEMBER_OF);
 for (Relationship rel : rels) {
 Node mn = rel.getStartNode();
 if (mn.equals(pn)) {
-Transaction tx = graphDb.beginTx();
+try (Transaction tx = graphDb.beginTx()) {
-try {
 rel.delete();
 tx.success();
-} finally {
-tx.finish();
 }
 // there should be only one
 break;
 }
 }
 * @param actor
 * @return
 */
 public Actor storeActor(Actor actor) {
 Node actorNode = getOrCreateActorNode(actor);
-Transaction tx = graphDb.beginTx();
+try (Transaction tx = graphDb.beginTx()) {
-try {
 // id
 String id = actor.getId();
 if (id != null) {
 actorNode.setProperty("id", id);
 }
 String uri = actor.getUri();
 if (uri != null) {
 actorNode.setProperty("uri", uri);
 }
 tx.success();
-} finally {
-tx.finish();
 }
 Actor storedActor = createActorFromNode(actorNode);
 return storedActor;
 }
 idx = getNodeIndex(NodeTypes.PERSON);
 }
 Node actorNode = idx.get("uri", uri).getSingle();
 if (actorNode != null) {
 // delete relations
-Transaction tx = graphDb.beginTx();
+try (Transaction tx = graphDb.beginTx()) {
-try {
 for (Relationship rel : actorNode.getRelationships()) {
 rel.delete();
 }
 if (!actorNode.hasRelationship()) {
 // this shouldn't happen
 deleteNode(actorNode);
 } else {
 logger.error("deleteActor: unable to delete: Node still has relations.");
 }
 tx.success();
-} finally {
-tx.finish();
 }
 }
 }
 /**
 * @param id
 * @return
 */
 public Annotation getAnnotationById(String id) {
 Annotation annot = null;
-try ( Transaction tx = graphDb.beginTx() ) {
+try (Transaction tx = graphDb.beginTx()) {
 Node annotNode = getNodeIndex(NodeTypes.ANNOTATION).get("id", id).getSingle();
 annot = createAnnotationFromNode(annotNode);
 tx.success();
 }
 return annot;
 }
 /**
 * @param annotNode
 * @return
 */
 public Annotation createAnnotationFromNode(Node annotNode) {
 Annotation annot = new Annotation();
-try ( Transaction tx = graphDb.beginTx() ) {
+try (Transaction tx = graphDb.beginTx()) {
 annot.setUri((String) annotNode.getProperty("id", null));
 annot.setBodyText((String) annotNode.getProperty("bodyText", null));
 annot.setBodyUri((String) annotNode.getProperty("bodyUri", null));
 /*
 * get annotation target and resource from relation
 */
 for (Relationship rel : annotNode.getRelationships(RelationTypes.ANNOTATES)) {
 Node target = rel.getEndNode();
 String type = (String) target.getProperty("TYPE");
 if (type.equals("TARGET")) {
 annot.setTarget(new Target((String) target.getProperty("uri", null)));
 } else if (type.equals("RESOURCE")) {
 annot.setResource(new Resource((String) target.getProperty("uri", null)));
 }
 }
 if (annot.getTarget() == null) {
-logger.error("annotation " + annotNode + " has no target node!");
+logger.warn("annotation " + annotNode + " has no target node!");
 }
 // get fragment from attribute
 annot.setTargetFragment((String) annotNode.getProperty("targetFragment", null));
 String ft = (String) annotNode.getProperty("fragmentType", null);
 if (ft != null) {
 annot.setFragmentType(FragmentTypes.valueOf(ft));
 }
 /*
 * get creator from relation
 */
 Relationship creatorRel = getRelation(annotNode, RelationTypes.CREATED, null);
 if (creatorRel != null) {
 Node creatorNode = creatorRel.getStartNode();
 Actor creator = createActorFromNode(creatorNode);
 annot.setCreator(creator);
 } else {
-logger.error("annotation " + annotNode + " has no creator node!");
+logger.warn("annotation " + annotNode + " has no creator node!");
 }
 /*
 * get creation date
 */
 annot.setCreated((String) annotNode.getProperty("created", null));
 /*
 * get permissions
 */
 Relationship adminRel = getRelation(annotNode, RelationTypes.PERMITS_ADMIN, null);
 if (adminRel != null) {
 Node adminNode = adminRel.getEndNode();
 Actor admin = createActorFromNode(adminNode);
 annot.setAdminPermission(admin);
 }
 Relationship deleteRel = getRelation(annotNode, RelationTypes.PERMITS_DELETE, null);
 if (deleteRel != null) {
 Node deleteNode = deleteRel.getEndNode();
 Actor delete = createActorFromNode(deleteNode);
 annot.setDeletePermission(delete);
 }
 Relationship updateRel = getRelation(annotNode, RelationTypes.PERMITS_UPDATE, null);
 if (updateRel != null) {
 Node updateNode = updateRel.getEndNode();
 Actor update = createActorFromNode(updateNode);
 annot.setUpdatePermission(update);
 }
 Relationship readRel = getRelation(annotNode, RelationTypes.PERMITS_READ, null);
 if (readRel != null) {
 Node readNode = readRel.getEndNode();
 Actor read = createActorFromNode(readNode);
 annot.setReadPermission(read);
 }
 /*
 * get tags
 */
 Set<String> tags = new HashSet<String>();
 for (Relationship rel : annotNode.getRelationships(RelationTypes.HAS_TAG)) {
 String tag = (String) rel.getEndNode().getProperty("name", null);
 if (tag != null) {
 tags.add(tag);
 }
 }
 annot.setTags(tags);
 tx.success();
 }
 return annot;
 }
 /**
 *
 * @param actorNode
 * @return
 */
 protected Actor createActorFromNode(Node actorNode) {
-if (actorNode == null) return null;
+if (actorNode == null)
-String id = (String) actorNode.getProperty("id", null);
+return null;
-String uri = (String) actorNode.getProperty("uri", null);
+try (Transaction tx = graphDb.beginTx()) {
-String name = (String) actorNode.getProperty("name", null);
+String id = (String) actorNode.getProperty("id", null);
-String type = (String) actorNode.getProperty("TYPE", null);
+String uri = (String) actorNode.getProperty("uri", null);
-if (type != null && type.equals("PERSON")) {
+String name = (String) actorNode.getProperty("name", null);
-return new Person(id, uri, name);
+String type = (String) actorNode.getProperty("TYPE", null);
-} else if (type != null && type.equals("GROUP")) {
+tx.success();
-return new Group(id, uri, name);
+if (type != null && type.equals("PERSON")) {
+return new Person(id, uri, name);
+} else if (type != null && type.equals("GROUP")) {
+return new Group(id, uri, name);
+}
 }
 return null;
 }
 public Tag createTagFromNode(Node tagNode) {
-if (tagNode == null) return null;
+if (tagNode == null)
-String name = (String) tagNode.getProperty("name", null);
+return null;
-String uri = (String) tagNode.getProperty("uri", null);
+String id;
-String id = (String) tagNode.getProperty("id", null);
+String uri;
+String name;
+try (Transaction tx = graphDb.beginTx()) {
+name = (String) tagNode.getProperty("name", null);
+uri = (String) tagNode.getProperty("uri", null);
+id = (String) tagNode.getProperty("id", null);
+tx.success();
+}
 return new Tag(id, uri, name);
 }
 /**
 public Target createTargetFromNode(Node targetNode) {
 return (Target) createUriFromNode(targetNode);
 }
 protected Uri createUriFromNode(Node uriNode) {
-if (uriNode == null) return null;
+if (uriNode == null)
-String uri = (String) uriNode.getProperty("uri", null);
+return null;
-String type = (String) uriNode.getProperty("TYPE", null);
+try (Transaction tx = graphDb.beginTx()) {
-if (type != null && type.equals("TARGET")) {
+String uri = (String) uriNode.getProperty("uri", null);
-return new Target(uri);
+String type = (String) uriNode.getProperty("TYPE", null);
-} else if (type != null && type.equals("RESOURCE")) {
+tx.success();
-return new Resource(uri);
+if (type != null && type.equals("TARGET")) {
+return new Target(uri);
+} else if (type != null && type.equals("RESOURCE")) {
+return new Resource(uri);
+}
 }
 return null;
 }
 /**
 * @param annot
 * @return
 */
 public Annotation storeAnnotation(Annotation annot) {
 Node annotNode = null;
-Transaction tx = graphDb.beginTx();
+try (Transaction tx = graphDb.beginTx()) {
-try {
 /*
 * create or get the annotation
 */
 String id = annot.getUri();
 if (id == null) {
 }
 String bodyUri = annot.getBodyUri();
 if (bodyUri != null) {
 annotNode.setProperty("bodyUri", bodyUri);
 }
 /*
 * the annotation target
 */
 Target target = annot.getTarget();
 Node targetNode = null;
 }
 }
 }
 tx.success();
-} finally {
-tx.finish();
 }
 // re-read and return annotation
 Annotation storedAnnot = createAnnotationFromNode(annotNode);
 return storedAnnot;
 * Deletes the annotation with the given id.
 *
 * @param id
 */
 public void deleteAnnotationById(String id) {
-Node annotNode = getNodeIndex(NodeTypes.ANNOTATION).get("id", id).getSingle();
+try (Transaction tx = graphDb.beginTx()) {
-if (annotNode != null) {
+Node annotNode = getNodeIndex(NodeTypes.ANNOTATION).get("id", id).getSingle();
-// delete related objects
+if (annotNode != null) {
-Transaction tx = graphDb.beginTx();
+// delete related objects
-try {
 for (Relationship rel : annotNode.getRelationships()) {
 // delete relation and the related node if it has no other
 // relations and is not permanent
 Node other = rel.getOtherNode(annotNode);
 rel.delete();
 if (!annotNode.hasRelationship()) {
 deleteNode(annotNode);
 } else {
 logger.error("deleteById: unable to delete: Node still has relations.");
 }
-tx.success();
+}
-} finally {
+tx.success();
-tx.finish();
-}
 }
 }
 /**
 * Returns all annotations with the given uri and/or user.
 */
 public List<Annotation> searchAnnotationByUriUser(String targetUri, String userUri) {
 List<Annotation> annotations = new ArrayList<Annotation>();
 if (targetUri != null) {
 // there should be only one
 Node target = getNodeFromIndex("uri", targetUri, NodeTypes.TARGET);
 if (target != null) {
-try ( Transaction tx = graphDb.beginTx() ) {
+try (Transaction tx = graphDb.beginTx()) {
 Iterable<Relationship> relations = target.getRelationships(RelationTypes.ANNOTATES);
 for (Relationship relation : relations) {
 Node ann = relation.getStartNode();
 if (ann.getProperty("TYPE", "").equals("ANNOTATION")) {
 Annotation annot = createAnnotationFromNode(ann);
 annotations.add(annot);
 } else {
 logger.error("ANNOTATES relation does not start with ANNOTATION: " + ann);
+}
 }
-}
+tx.success();
-tx.success();
 }
 }
 }
 if (userUri != null) {
 // there should be only one
 Node person = getPersonNodeByUri(userUri);
 if (person != null) {
-Iterable<Relationship> relations = person.getRelationships(RelationTypes.CREATED);
+try (Transaction tx = graphDb.beginTx()) {
-for (Relationship relation : relations) {
+Iterable<Relationship> relations = person.getRelationships(RelationTypes.CREATED);
-Node ann = relation.getEndNode();
+for (Relationship relation : relations) {
-if (ann.getProperty("TYPE", "").equals("ANNOTATION")) {
+Node ann = relation.getEndNode();
-Annotation annot = createAnnotationFromNode(ann);
+if (ann.getProperty("TYPE", "").equals("ANNOTATION")) {
-annotations.add(annot);
+Annotation annot = createAnnotationFromNode(ann);
-} else {
+annotations.add(annot);
-logger.error("CREATED relation does not end with ANNOTATION: " + ann);
+} else {
+logger.error("CREATED relation does not end with ANNOTATION: " + ann);
+}
 }
+tx.success();
 }
 }
 }
 // TODO: if both uri and user are given we should intersect
 return annotations;
 }
 /**
 * Returns Relationship of type from Node start to Node end. Creates one if
 * @param type
 * @param end
 * @return
 */
 protected Relationship getOrCreateRelation(Node start, RelationshipType type, Node end) {
-if (start == null || end == null) return null;
+if (start == null || end == null)
+return null;
 if (start.hasRelationship()) {
 // there are relations
-Iterable<Relationship> rels = start.getRelationships(type, Direction.OUTGOING);
+try (Transaction tx = graphDb.beginTx()) {
-for (Relationship rel : rels) {
+Iterable<Relationship> rels = start.getRelationships(type, Direction.OUTGOING);
-if (rel.getEndNode().equals(end)) {
+for (Relationship rel : rels) {
-// relation exists
+if (rel.getEndNode().equals(end)) {
-return rel;
+// relation exists
-}
+tx.success();
+return rel;
+}
+}
+tx.success();
 }
 }
 // create new one
 Relationship rel;
-Transaction tx = graphDb.beginTx();
+try (Transaction tx = graphDb.beginTx()) {
-try {
 rel = start.createRelationshipTo(end, type);
 tx.success();
-} finally {
-tx.finish();
 }
 return rel;
 }
 protected Node getOrCreateAnnotationNode(String id) {
 Index<Node> idx = getNodeIndex(NodeTypes.ANNOTATION);
-IndexHits<Node> annotations = idx.get("id", id);
+Node annotation;
-Node annotation = annotations.getSingle();
+try (Transaction tx = graphDb.beginTx()) {
-if (annotation == null) {
+IndexHits<Node> annotations = idx.get("id", id);
-// does not exist yet
+annotation = annotations.getSingle();
-Transaction tx = graphDb.beginTx();
+if (annotation == null) {
-try {
+// does not exist yet
 annotation = graphDb.createNode();
 annotation.setProperty("TYPE", NodeTypes.ANNOTATION.name());
 annotation.setProperty("id", id);
 idx.add(annotation, "id", id);
-tx.success();
+}
-} finally {
+tx.success();
-tx.finish();
-}
 }
 return annotation;
 }
 protected Node getOrCreateUriNode(String uri, NodeTypes type) {
 Index<Node> idx = getNodeIndex(type);
-IndexHits<Node> targets = idx.get("uri", uri);
+Node target;
-Node target = targets.getSingle();
+try (Transaction tx = graphDb.beginTx()) {
-if (target == null) {
+IndexHits<Node> targets = idx.get("uri", uri);
-// does not exist yet
+target = targets.getSingle();
-Transaction tx = graphDb.beginTx();
+if (target == null) {
-try {
+// does not exist yet
 target = graphDb.createNode();
 target.setProperty("TYPE", type.name());
 target.setProperty("uri", uri);
 idx.add(target, "uri", uri);
-tx.success();
+}
-} finally {
+tx.success();
-tx.finish();
-}
 }
 return target;
 }
 protected Node getActorNode(Actor actor) {
 // Person/Group is identified by URI or id
 String uri = actor.getUriString();
 Index<Node> idx;
+Node person;
 if (actor.isGroup()) {
 idx = getNodeIndex(NodeTypes.GROUP);
 } else {
 idx = getNodeIndex(NodeTypes.PERSON);
 }
-IndexHits<Node> persons = idx.get("uri", uri);
+try (Transaction tx = graphDb.beginTx()) {
-Node person = persons.getSingle();
+IndexHits<Node> persons = idx.get("uri", uri);
+person = persons.getSingle();
+tx.success();
+}
 return person;
 }
 protected Node getOrCreateActorNode(Actor actor) {
 // Person/Group is identified by URI or id
 String uri = actor.getUriString();
 String name = actor.getName();
 String id = actor.getId();
-Index<Node> idx;
+Node person;
-if (actor.isGroup()) {
+try (Transaction tx = graphDb.beginTx()) {
-idx = getNodeIndex(NodeTypes.GROUP);
+Index<Node> idx;
-} else {
+if (actor.isGroup()) {
-idx = getNodeIndex(NodeTypes.PERSON);
+idx = getNodeIndex(NodeTypes.GROUP);
-}
+} else {
-IndexHits<Node> persons = idx.get("uri", uri);
+idx = getNodeIndex(NodeTypes.PERSON);
-Node person = persons.getSingle();
+}
-if (person == null) {
+IndexHits<Node> persons = idx.get("uri", uri);
-// does not exist yet
+person = persons.getSingle();
-Transaction tx = graphDb.beginTx();
+if (person == null) {
-try {
+// does not exist yet
 person = graphDb.createNode();
 if (actor.isGroup()) {
 person.setProperty("TYPE", NodeTypes.GROUP.name());
 } else {
 person.setProperty("TYPE", NodeTypes.PERSON.name());
 person.setProperty("name", name);
 }
 if (id != null) {
 person.setProperty("id", id);
 }
-tx.success();
+}
-} finally {
+tx.success();
-tx.finish();
-}
 }
 return person;
 }
 protected Node getOrCreateTagNode(Tag inTag) {
 Index<Node> idx = getNodeIndex(NodeTypes.TAG);
 String tagname = inTag.getName();
-IndexHits<Node> tags = idx.get("name", tagname);
+Node tag;
-Node tag = tags.getSingle();
+try (Transaction tx = graphDb.beginTx()) {
-if (tag == null) {
+IndexHits<Node> tags = idx.get("name", tagname);
-// does not exist yet
+tag = tags.getSingle();
-Transaction tx = graphDb.beginTx();
+if (tag == null) {
-try {
+// does not exist yet
 tag = graphDb.createNode();
 tag.setProperty("TYPE", NodeTypes.TAG.name());
 tag.setProperty("name", tagname);
 idx.add(tag, "name", tagname);
 tag.setProperty("id", inTag.getId());
 tag.setProperty("uri", inTag.getUri());
 idx.add(tag, "uri", inTag.getUri());
+}
 tx.success();
-} finally {
-tx.finish();
-}
 }
 return tag;
 }
 /**
 newActorNode = getOrCreateActorNode(actor);
 }
 Relationship rel = getRelation(annotNode, type, null);
 if (rel != null) {
 // relation exists
-Node oldActorNode = rel.getEndNode();
+try (Transaction tx = graphDb.beginTx()) {
-if (!oldActorNode.equals(newActorNode)) {
+Node oldActorNode = rel.getEndNode();
-// new admin is different
+if (!oldActorNode.equals(newActorNode)) {
-Transaction tx = graphDb.beginTx();
+// new admin is different
-try {
 rel.delete();
 tx.success();
-} finally {
-tx.finish();
 }
 if (newActorNode != null) {
 rel = getOrCreateRelation(annotNode, type, newActorNode);
 }
+tx.success();
 }
 } else {
 // no relation yet
 if (newActorNode != null) {
 rel = getOrCreateRelation(annotNode, type, newActorNode);
 * Unindexes and deletes given Node if it has no relations.
 *
 * @param node
 */
 protected void deleteNode(Node node) {
-Transaction tx = graphDb.beginTx();
+try (Transaction tx = graphDb.beginTx()) {
-try {
 if (node.hasRelationship()) {
 logger.error("deleteNode: unable to delete: Node still has relations.");
 } else {
 String ts = (String) node.getProperty("TYPE", null);
 try {
 logger.error("deleteNode: unable to get TYPE of node: " + node);
 }
 node.delete();
 }
 tx.success();
-} finally {
-tx.finish();
 }
 }
 /**
 * returns the (first) Relationship of RelationTypes type from Node start.
 * @param direction
 * @return
 */
 protected Relationship getRelation(Node start, RelationTypes type, Direction direction) {
 Iterable<Relationship> rels;
-if (direction == null) {
+try (Transaction tx = graphDb.beginTx()) {
-// ignore direction
+if (direction == null) {
-rels = start.getRelationships(type);
+// ignore direction
-} else {
+rels = start.getRelationships(type);
-rels = start.getRelationships(type, direction);
+} else {
-}
+rels = start.getRelationships(type, direction);
-for (Relationship rel : rels) {
+}
-// just the first one
+tx.success();
-return rel;
+for (Relationship rel : rels) {
+// just the first one
+return rel;
+}
 }
 return null;
 }
 /**
 public List<Annotation> getAnnotationsByTag(String tagUri) {
 ArrayList<Annotation> ret = new ArrayList<Annotation>();
 Node tag = getTagNodeByUri(tagUri);
 if (tag != null) {
-Iterable<Relationship> rels = tag.getRelationships(Direction.INCOMING, RelationTypes.HAS_TAG);
+try (Transaction tx = graphDb.beginTx()) {
-for (Relationship rel : rels) {
+Iterable<Relationship> rels = tag.getRelationships(Direction.INCOMING, RelationTypes.HAS_TAG);
-Node node = rel.getStartNode();
+for (Relationship rel : rels) {
-ret.add(createAnnotationFromNode(node));
+Node node = rel.getStartNode();
+ret.add(createAnnotationFromNode(node));
+}
+tx.success();
 }
 }
 return ret;
 }
 public List<Annotation> getAnnotationsByResource(String resourceUri) {
 ArrayList<Annotation> ret = new ArrayList<Annotation>();
 Node res = getNodeFromIndex("uri", resourceUri, NodeTypes.RESOURCE);
 if (res != null) {
-Iterable<Relationship> rels = res.getRelationships(Direction.INCOMING, RelationTypes.ANNOTATES);
+try (Transaction tx = graphDb.beginTx()) {
-for (Relationship rel : rels) {
+Iterable<Relationship> rels = res.getRelationships(Direction.INCOMING, RelationTypes.ANNOTATES);
-Node an = rel.getStartNode();
+for (Relationship rel : rels) {
-Node rn = rel.getEndNode();
+Node an = rel.getStartNode();
-if (rn.getProperty("TYPE", "").equals("RESOURCE")) {
+Node rn = rel.getEndNode();
-logger.error("getAnnotationsByResource got ANNOTATES != RESOURCE");
+if (rn.getProperty("TYPE", "").equals("RESOURCE")) {
-}
+logger.error("getAnnotationsByResource got ANNOTATES != RESOURCE");
-ret.add(createAnnotationFromNode(an));
+}
+ret.add(createAnnotationFromNode(an));
+}
+tx.success();
 }
 }
 return ret;
 }

Mercurial > hg > AnnotationManagerN4J

comparison src/main/java/de/mpiwg/itgroup/annotations/neo4j/AnnotationStore.java @ 68:39bc52f9b102