1 files changed, 381 insertions, 0 deletions
diff --git a/verigraph/src/it/polito/neo4j/manager/Neo4jDBManager.java b/verigraph/src/it/polito/neo4j/manager/Neo4jDBManager.java
new file mode 100644
index 0000000..40789c8
--- /dev/null
+++ b/verigraph/src/it/polito/neo4j/manager/Neo4jDBManager.java
@@ -0,0 +1,381 @@
+/*******************************************************************************
+ * Copyright (c) 2017 Politecnico di Torino and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Apache License, Version 2.0
+ * which accompanies this distribution, and is available at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *******************************************************************************/
+package it.polito.neo4j.manager;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.logging.Logger;
+
+import javax.ws.rs.BadRequestException;
+import javax.ws.rs.ForbiddenException;
+import javax.ws.rs.NotFoundException;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.QueryParam;
+import javax.xml.bind.JAXBException;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+
+import it.polito.neo4j.exceptions.DuplicateNodeException;
+import it.polito.neo4j.exceptions.MyInvalidObjectException;
+import it.polito.neo4j.exceptions.MyNotFoundException;
+import it.polito.neo4j.jaxb.ObjectFactory;
+import it.polito.neo4j.jaxb.Paths;
+import it.polito.neo4j.translator.GraphToNeo4j;
+import it.polito.neo4j.translator.Neo4jToGraph;
+import it.polito.neo4j.exceptions.MyInvalidDirectionException;
+import it.polito.neo4j.exceptions.MyInvalidIdException;
+import it.polito.verigraph.exception.DataNotFoundException;
+import it.polito.verigraph.model.Configuration;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Neighbour;
+import it.polito.verigraph.model.Node;
+import it.polito.verigraph.service.VerigraphLogger;
+
+public class Neo4jDBManager {
+
+    public static Neo4jLibrary lib = Neo4jLibrary.getNeo4jLibrary();
+    //static ObjectFactory obFactory = new ObjectFactory();
+
+    public static VerigraphLogger vlogger = VerigraphLogger.getVerigraphlogger();
+
+
+    public it.polito.verigraph.model.Graph updateGraph(it.polito.verigraph.model.Graph graph) throws JAXBException, JsonParseException, JsonMappingException, IOException, MyInvalidIdException{
+
+        it.polito.neo4j.jaxb.Graph graph_xml=GraphToNeo4j.generateObject(graph);
+        it.polito.neo4j.jaxb.Graph graphReturned;
+        long graphId;
+
+        try{
+            graphId = graph.getId();
+            graphReturned = lib.updateGraph(graph_xml, graphId);
+            it.polito.verigraph.model.Graph g=Neo4jToGraph.generateGraph(graphReturned);
+            return g;
+
+        }
+        catch(MyNotFoundException e1){
+            vlogger.logger.info("error update 1");
+            throw new NotFoundException();
+        }
+
+        catch(DuplicateNodeException e3){
+            vlogger.logger.info("error update 2");
+            throw new BadRequestException(e3.getMessage());
+        }
+        catch(MyInvalidObjectException e4){
+            vlogger.logger.info("error update 3");
+            throw new BadRequestException(e4.getMessage());
+        }
+    }
+
+    public void deleteGraph(long id){
+
+        try{
+            lib.deleteGraph(id);
+        }
+        catch(MyNotFoundException e1){
+            throw new NotFoundException();
+        }
+    }
+
+    public it.polito.verigraph.model.Graph addGraph(it.polito.verigraph.model.Graph graph) throws JAXBException, JsonParseException, JsonMappingException, IOException, MyInvalidIdException {
+
+        it.polito.neo4j.jaxb.Graph graph_xml=GraphToNeo4j.generateObject(graph);
+        it.polito.neo4j.jaxb.Graph graphReturned;
+        it.polito.neo4j.jaxb.Node node;
+
+        try{
+            graphReturned = lib.createGraph(graph_xml);
+            it.polito.verigraph.model.Graph g=Neo4jToGraph.generateGraph(graphReturned);
+            return g;
+
+        }
+        catch(MyNotFoundException e){
+            e.printStackTrace();
+            throw new NotFoundException();
+
+        }
+    }
+    public it.polito.verigraph.model.Graph getGraph(long graphId) throws JAXBException, JsonParseException, JsonMappingException, IOException {
+
+        it.polito.neo4j.jaxb.Graph graphReturned;
+
+        try{
+            graphReturned = lib.getGraph(graphId);
+
+            it.polito.verigraph.model.Graph g=Neo4jToGraph.generateGraph(graphReturned);
+
+            return g;
+
+        }
+        catch(MyNotFoundException e){
+            e.printStackTrace();
+            throw new NotFoundException();
+        }
+
+    }
+
+    public List<it.polito.verigraph.model.Graph> getGraphs() throws JsonProcessingException, MyNotFoundException {
+
+        List<it.polito.verigraph.model.Graph> graphsReturned=new ArrayList<it.polito.verigraph.model.Graph>();
+        it.polito.neo4j.jaxb.Graphs graphs;
+
+        graphs = lib.getGraphs();
+        for(it.polito.neo4j.jaxb.Graph tmp : graphs.getGraph()){
+            it.polito.verigraph.model.Graph g=Neo4jToGraph.generateGraph(tmp);
+            graphsReturned.add(g);
+        }
+
+        return graphsReturned;
+
+    }
+
+    public it.polito.verigraph.model.Neighbour addNeighbours(long graphId, long nodeId, it.polito.verigraph.model.Neighbour neighbour) throws JsonProcessingException {
+
+        it.polito.neo4j.jaxb.Neighbour neighbour_xml=GraphToNeo4j.NeighbourToNeo4j(neighbour);
+        it.polito.neo4j.jaxb.Neighbour neighReturned;
+        it.polito.verigraph.model.Neighbour n;
+        try{
+            neighReturned = lib.createNeighbour(neighbour_xml, graphId, nodeId);
+            n=Neo4jToGraph.NeighbourToVerigraph(neighReturned);
+            return n;
+        }
+        catch(MyNotFoundException e2){
+            e2.printStackTrace();
+            throw new NotFoundException();
+        }
+    }
+
+    public Neighbour deleteNeighbour(long graphId, long nodeId, long neighbourId) {
+
+        try{
+            it.polito.neo4j.jaxb.Neighbour n=lib.getNeighbour(graphId, nodeId, neighbourId);
+            if(n==null){
+                throw new DataNotFoundException("Neighbour validation failed: '"+ neighbourId
+                        + "' is not a valid id for a neighbour of node '" + nodeId + "'" + "' of graph '" + graphId + "'");
+            }else{
+                lib.deleteNeighbour(graphId, nodeId, neighbourId);
+                return Neo4jToGraph.NeighbourToVerigraph(n);
+            }
+        }
+        catch(MyNotFoundException e1){
+            e1.printStackTrace();
+            throw new NotFoundException();
+        }catch (JsonProcessingException e) {
+            throw new NotFoundException("jsonprocessing node");
+        }
+
+    }
+
+    public Neighbour updateNeighbour(long graphId, long nodeId, it.polito.verigraph.model.Neighbour neighbour) throws JsonProcessingException {
+        it.polito.neo4j.jaxb.Neighbour neighbour_xml=GraphToNeo4j.NeighbourToNeo4j(neighbour);
+        it.polito.neo4j.jaxb.Node nodeReturned;
+        Neighbour r;
+        try{
+            nodeReturned=lib.updateNeighbour(neighbour_xml, graphId, nodeId, neighbour_xml.getId());
+            r=Neo4jToGraph.NeighbourToVerigraph(lib.getNeighbour(graphId, nodeReturned.getId(), neighbour_xml.getId()));
+            return r;
+        }
+        catch(MyNotFoundException e2){
+            throw new NotFoundException();
+        } catch (MyInvalidObjectException e) {
+            e.printStackTrace();
+        }
+        return null;
+
+    }
+
+    public it.polito.verigraph.model.Node addNode(long graphId, it.polito.verigraph.model.Node node) throws IOException, MyInvalidIdException {
+        it.polito.neo4j.jaxb.Node node_xml=GraphToNeo4j.NodeToNeo4j(node);
+        it.polito.neo4j.jaxb.Node nodeReturned;
+        it.polito.verigraph.model.Node node_v=new it.polito.verigraph.model.Node();
+        try
+        {
+
+            nodeReturned = lib.createNode(node_xml, graphId);
+            node_v=Neo4jToGraph.NodeToVerigraph(nodeReturned);
+        }
+        catch(MyNotFoundException e1){
+            e1.printStackTrace();
+            throw new NotFoundException();
+        }
+
+        catch(DuplicateNodeException e3){
+            e3.printStackTrace();
+            throw new BadRequestException();
+        }
+        return node_v;
+    }
+
+    public Node updateNode(long graphId, Node node, long id) throws IOException, MyInvalidIdException {
+        it.polito.neo4j.jaxb.Node node_xml=GraphToNeo4j.NodeToNeo4j(node);
+        it.polito.neo4j.jaxb.Node nodeReturned;
+        Node node_v;
+        try{
+            nodeReturned = lib.updateNode(node_xml, graphId, id);
+            node_v=Neo4jToGraph.NodeToVerigraph(nodeReturned);
+            return node_v;
+        }
+        catch(MyNotFoundException e2){
+            e2.printStackTrace();
+            throw new NotFoundException();
+        }
+        catch(MyInvalidObjectException e3){
+            e3.printStackTrace();
+            throw new BadRequestException(e3.getMessage());
+        }
+
+    }
+
+    public Node deleteNode(long graphId, long nodeId) {
+
+        try{
+            it.polito.neo4j.jaxb.Node n=lib.getNodeById(nodeId, graphId);
+            lib.deleteNode(graphId, nodeId);
+            return Neo4jToGraph.NodeToVerigraph(n);
+        }
+        catch(MyNotFoundException e1){
+            throw new NotFoundException("graph or node not found");
+        } catch (JsonProcessingException e) {
+            throw new NotFoundException("jsonprocessing node");
+        }
+    }
+
+    public Paths getPath(long graphId, String source, String destination, String direction) throws MyInvalidDirectionException {
+        it.polito.neo4j.jaxb.Paths paths=(new ObjectFactory()).createPaths();
+        try{
+            if(source == null || destination == null || direction == null)
+                throw new DataNotFoundException("Missing query parameters");
+            paths =  lib.findAllPathsBetweenTwoNodes(graphId, source, destination,direction);
+        }
+        catch(MyNotFoundException e1){
+            e1.printStackTrace();
+            throw new NotFoundException();
+
+        }
+
+        return paths;
+    }
+
+    public Map<Long, Node> getNodes(long graphId) throws JsonProcessingException {
+        Map<Long, Node> nodes=new HashMap<Long, Node>();
+        try
+        {
+            Set<it.polito.neo4j.jaxb.Node> set= lib.getNodes(graphId);
+            nodes=Neo4jToGraph.NodesToVerigraph(set);
+        }
+        catch(MyNotFoundException e1){
+            e1.printStackTrace();
+            throw new NotFoundException();
+        }
+        return nodes;
+
+    }
+
+    public Map<Long, Neighbour> getNeighbours(long graphId, long nodeId) throws JsonProcessingException {
+        Map<Long, Neighbour> neighbours=new HashMap<Long, Neighbour>();
+        try
+        {
+            Set<it.polito.neo4j.jaxb.Neighbour> set= lib.getNeighbours(graphId, nodeId);
+            neighbours=Neo4jToGraph.NeighboursToVerigraph(set);
+            return neighbours;
+        }
+        catch(MyNotFoundException e1){
+            e1.printStackTrace();
+            throw new NotFoundException();
+        }
+
+    }
+
+    public Node getNodeByName(long graphId, String name) throws JsonProcessingException {
+
+        it.polito.verigraph.model.Node node;
+        try
+        {
+            it.polito.neo4j.jaxb.Node set= lib.getNodeByName(name, graphId);
+            if(set==null)
+                return null;
+            else{
+                node=Neo4jToGraph.NodeToVerigraph(set);
+                return node;
+            }
+        }
+        catch(MyNotFoundException e1){
+            e1.printStackTrace();
+            throw new NotFoundException();
+        }
+
+    }
+
+    public Node getNodeById(long nodeId, long graphId) throws JsonProcessingException {
+        it.polito.verigraph.model.Node node;
+        try
+        {
+            it.polito.neo4j.jaxb.Node set= lib.getNodeById(nodeId, graphId);
+            if(set==null)
+                return null;
+            else{
+                node=Neo4jToGraph.NodeToVerigraph(set);
+                return node;
+            }
+        }
+        catch(MyNotFoundException e1){
+            e1.printStackTrace();
+            throw new NotFoundException();
+        }
+    }
+
+    public Neighbour getNeighbour(long graphId, long nodeId, long neighbourId) throws JsonProcessingException {
+        try
+        {
+            it.polito.neo4j.jaxb.Neighbour set= lib.getNeighbour(graphId, nodeId, neighbourId);
+            if(set!=null)
+                return Neo4jToGraph.NeighbourToVerigraph(set);
+            else
+                return null;
+        }
+        catch(MyNotFoundException e1){
+            e1.printStackTrace();
+            throw new NotFoundException();
+        }
+    }
+
+    public void checkGraph(long graphId) {
+
+        try
+        {
+            lib.checkGraph(graphId);
+        }
+        catch(MyNotFoundException e1){
+            e1.printStackTrace();
+            throw new NotFoundException();
+        }
+    }
+
+    public Configuration updateConfiguration(long nodeId, long graphId, Configuration nodeConfiguration, Node node) throws JsonParseException, JsonMappingException, IOException, MyInvalidIdException {
+
+        try{
+
+            it.polito.neo4j.jaxb.Configuration conf=GraphToNeo4j.ConfToNeo4j(nodeConfiguration, node);
+            it.polito.neo4j.jaxb.Configuration c=lib.updateConfiguration(nodeId, graphId, conf);
+            Configuration r=Neo4jToGraph.ConfToVerigraph(c);
+            return r;
+        }
+        catch(MyNotFoundException e2){
+            e2.printStackTrace();
+            throw new NotFoundException();
+        }
+    }
+
+}