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

comparison src/main/java/de/mpiwg/itgroup/annotations/neo4j/AnnotationStore.java @ 32:0731c4549065

UI for editing groups and persons works now. (still no authorisation!)

author	casties
date	Tue, 25 Sep 2012 21:59:21 +0200
parents	3be0ebb6d5ad
children	86bb29132ba6

comparison

equal deleted inserted replaced

-:05b631a084d0
+:0731c4549065
 *
 */
 package de.mpiwg.itgroup.annotations.neo4j;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Calendar;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import de.mpiwg.itgroup.annotations.Group;
 import de.mpiwg.itgroup.annotations.Person;
 import de.mpiwg.itgroup.annotations.Tag;
 /**
+* Neo4J based Annotation store.
+*
 * @author casties
 *
 */
 public class AnnotationStore {
 protected GraphDatabaseService graphDb;
 public static enum NodeTypes {
 ANNOTATION, PERSON, TARGET, GROUP, TAG
 }
+// types of nodes that should not be automatically deleted.
+public Set<String> permanentNodeTypes = new HashSet<String>(Arrays.asList("PERSON", "GROUP", "TAG"));
 protected List<Index<Node>> nodeIndexes;
 public static enum RelationTypes implements RelationshipType {
 ANNOTATES, CREATED, PERMITS_ADMIN, PERMITS_DELETE, PERMITS_UPDATE, PERMITS_READ, MEMBER_OF, HAS_TAG
 }
 return actors;
 }
 /**
-* Returns List of Groups.
+* Returns List of Groups. Key has to be indexed.
-* Key has to be indexed.
 *
 * @param key
 * @param query
 * @return
 */
 Actor group = createActorFromNode(groupNode);
 groups.add((Group) group);
 }
 return groups;
 }
+/**
-/**
+* Returns List of Tags. Key has to be indexed.
-* Returns List of Tags.
-* Key has to be indexed.
 *
 * @param key
 * @param query
 * @return
 */
 tags.add(tag);
 }
 return tags;
 }
+/**
-/**
 * Returns List of Groups the person is member of.
 *
 * @param person
 * @return
 */
 }
 members.add((Person) member);
 }
 return members;
 }
 /**
 * Add Person newMember to Group group.
 *
 * @param group
 * @param member
 getOrCreateRelation(pn, RelationTypes.MEMBER_OF, gn);
 addedMember = member;
 }
 return addedMember;
 }
 /**
 * Delete Person oldMember from Group group.
 *
 * @param group
 * @param member
 */
 public void deleteGroupMember(Group group, Person member) {
 Node gn = getActorNode(group);
+Node pn = getActorNode(member);
 Iterable<Relationship> rels = gn.getRelationships(RelationTypes.MEMBER_OF);
 for (Relationship rel : rels) {
 Node mn = rel.getStartNode();
-if (mn.equals(member)) {
+if (mn.equals(pn)) {
-rel.delete();
+Transaction tx = graphDb.beginTx();
+try {
+rel.delete();
+tx.success();
+} finally {
+tx.finish();
+}
 // there should be only one
 break;
 }
 }
 }
 /**
 * Returns the stored Actor matching the given one.
 *
 * @param actor
 * @return
 */
 public Actor getActor(Actor actor) {
-	Node actorNode = getActorNode(actor);
+Node actorNode = getActorNode(actor);
-	Actor storedActor = createActorFromNode(actorNode);
+Actor storedActor = createActorFromNode(actorNode);
-	return storedActor;
+return storedActor;
 }
 /**
-* Stores an Actor (Person or Group). Creates a new actor Node or returns an existing one.
+* Stores an Actor (Person or Group). Creates a new actor Node or update an
+* existing one.
 *
 * @param actor
 * @return
 */
 public Actor storeActor(Actor actor) {
-	Node actorNode = getOrCreateActorNode(actor);
+Node actorNode = getOrCreateActorNode(actor);
-	Actor storedActor = createActorFromNode(actorNode);
+Transaction tx = graphDb.beginTx();
-	return storedActor;
+try {
-}
+// id
+String id = actor.getId();
+if (id != null) {
+actorNode.setProperty("id", id);
+}
+// name
+String name = actor.getName();
+if (name != null) {
+actorNode.setProperty("name", name);
+}
+// uri
+String uri = actor.getUri();
+if (uri != null) {
+actorNode.setProperty("uri", uri);
+}
+tx.success();
+} finally {
+tx.finish();
+}
+Actor storedActor = createActorFromNode(actorNode);
+return storedActor;
+}
+/**
+* Deletes the given Actor.
+*
+* @param actor
+*/
+public void deleteActor(Actor actor) {
+String uri = actor.getUriString();
+Index<Node> idx;
+if (actor.isGroup()) {
+idx = getNodeIndex(NodeTypes.GROUP);
+} else {
+idx = getNodeIndex(NodeTypes.PERSON);
+}
+Node actorNode = idx.get("uri", uri).getSingle();
+if (actorNode != null) {
+// delete relations
+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();
+}
+}
+}
 /**
 * Returns the Annotation with the given id.
 *
 * @param id
 * @return
 *
 * @param actorNode
 * @return
 */
 protected Actor createActorFromNode(Node actorNode) {
+if (actorNode == null) return null;
 String id = (String) actorNode.getProperty("id", null);
 String uri = (String) actorNode.getProperty("uri", null);
 String name = (String) actorNode.getProperty("name", null);
 String type = (String) actorNode.getProperty("TYPE", null);
 if (type != null && type.equals("PERSON")) {
 } else if (type != null && type.equals("GROUP")) {
 return new Group(id, uri, name);
 }
 return null;
 }
 public Tag createTagFromNode(Node tagNode) {
-	String name = (String) tagNode.getProperty("name", null);
+if (tagNode == null) return null;
-	String uri = (String) tagNode.getProperty("uri", null);
+String name = (String) tagNode.getProperty("name", null);
-	String id = (String) tagNode.getProperty("id", null);
+String uri = (String) tagNode.getProperty("uri", null);
+String id = (String) tagNode.getProperty("id", null);
-	return new Tag(id, uri, name);
+return new Tag(id, uri, name);
-	}
+}
 /**
 * Store a new annotation in the store or update an existing one. Returns
 * the stored annotation.
 *
 }
 if (!newTags.isEmpty()) {
 // still tags to add
 for (String tag : newTags) {
 // create new tag
-Node tagNode = getOrCreateTagNode(new Tag(null,null,tag));
+Node tagNode = getOrCreateTagNode(new Tag(null, null, tag));
 getOrCreateRelation(annotNode, RelationTypes.HAS_TAG, tagNode);
 }
 }
 }
 /**
 * Deletes the annotation with the given id.
 *
 * @param id
 */
-public void deleteById(String id) {
+public void deleteAnnotationById(String id) {
 Node annotNode = getNodeIndex(NodeTypes.ANNOTATION).get("id", id).getSingle();
 if (annotNode != null) {
 // delete related objects
 Transaction tx = graphDb.beginTx();
 try {
 for (Relationship rel : annotNode.getRelationships()) {
 // delete relation and the related node if it has no other
-// relations
+// relations and is not permanent
 Node other = rel.getOtherNode(annotNode);
 rel.delete();
-if (!other.hasRelationship()) {
+if (!(other.hasRelationship() || permanentNodeTypes.contains(other.getProperty("TYPE", null)))) {
 deleteNode(other);
 }
 }
 if (!annotNode.hasRelationship()) {
 deleteNode(annotNode);
 * @param userUri
 * @param limit
 * @param offset
 * @return
 */
-public List<Annotation> searchByUriUser(String targetUri, String userUri, String limit, String offset) {
+public List<Annotation> searchAnnotationByUriUser(String targetUri, String userUri, String limit, String offset) {
 List<Annotation> annotations = new ArrayList<Annotation>();
 if (targetUri != null) {
 // there should be only one
 Node target = getNodeIndex(NodeTypes.TARGET).get("uri", targetUri).getSingle();
 if (target != null) {
 }
 IndexHits<Node> persons = idx.get("uri", uri);
 Node person = persons.getSingle();
 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();
 try {
 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 String.format("%s%s%s", ANNOTATION_URI_BASE, prefix, time);
 }
-	public List<Annotation> getAnnotationsByTag(String tagUri) {
+public List<Annotation> getAnnotationsByTag(String tagUri) {
-		ArrayList<Annotation> ret = new  ArrayList<Annotation>();
+ArrayList<Annotation> ret = new ArrayList<Annotation>();
-		Node tag = getTagNodeByUri(tagUri);
+Node tag = getTagNodeByUri(tagUri);
+Iterable<Relationship> rels = tag.getRelationships(Direction.INCOMING, RelationTypes.HAS_TAG);
-		Iterable<Relationship> rels = tag.getRelationships(Direction.INCOMING,RelationTypes.HAS_TAG);
+for (Relationship rel : rels) {
-		for (Relationship rel:rels){
+Node node = rel.getStartNode();
-			Node node = rel.getStartNode();
+ret.add(createAnnotationFromNode(node));
-			ret.add(createAnnotationFromNode(node));
+}
-		}
+return ret;
-		return ret;
+}
-	}
 }

Mercurial > hg > AnnotationManagerN4J

comparison src/main/java/de/mpiwg/itgroup/annotations/neo4j/AnnotationStore.java @ 32:0731c4549065