Implemented reverse operator

Close #14

Delete commented code
Fix typo in KnoxController

Author: Zackhardtoname

src/main/java/knox/spring/data/neo4j/controller/KnoxController.java

@@ -277,7 +277,7 @@ public ResponseEntity<String> orBranches(@RequestParam(value = "targetSpaceID",
     }
 
 	/**
-	 * @api {post} /branch/repeat Repeat
+	 * @api {post} /branch/Repeat
 	 * @apiName repeatBranches
 	 * @apiGroup Branch
 	 * 
@@ -522,6 +522,38 @@ public ResponseEntity<String> mergeDesignSpaces(@RequestParam(value = "inputSpac
 		}
 	}
 
+	/**
+	 * @api {post} /designSpace/reverse Reverse
+	 * @apiName reverseDesignSpaces
+	 * @apiGroup DesignSpace
+	 *
+	 * @apiParam {String[]} inputSpaceIDs IDs for the input design spaces to be reversed.
+	 * @apiParam {String} [outputSpaceID] ID for the output design space resulting from reverse.  If omitted, then the result is
+	 *  stored in the first input design space.
+	 *
+	 * @apiDescription Reverse the edges from input design spaces.
+	 */
+	@RequestMapping(value = "/designSpace/reverse", method = RequestMethod.POST)
+	public ResponseEntity<String> reverseDesignSpaces(@RequestParam(value = "inputSpaceID", required = true) String inputSpaceID,
+													@RequestParam(value = "outputSpaceID", required = false) String outputSpaceID) {
+		try {
+			long startTime = System.nanoTime();
+
+			if (outputSpaceID == null) {
+				designSpaceService.reverseDesignSpaces(inputSpaceID);
+			} else {
+				designSpaceService.reverseDesignSpaces(inputSpaceID, outputSpaceID);
+			}
+
+			return new ResponseEntity<String>("{\"message\": \"Design space was successfully reversed after " +
+					(System.nanoTime() - startTime) + " ns.\"}", HttpStatus.NO_CONTENT);
+		} catch (ParameterEmptyException | DesignSpaceNotFoundException |
+				DesignSpaceConflictException | DesignSpaceBranchesConflictException ex) {
+			return new ResponseEntity<String>("{\"message\": \"" + ex.getMessage() + "\"}",
+					HttpStatus.BAD_REQUEST);
+		}
+	}
+
 	/**
 	 * @api {post} /designSpace/or OR
 	 * @apiName orDesignSpaces

src/main/java/knox/spring/data/neo4j/domain/DesignSpace.java

@@ -223,4 +223,4 @@ public Set<Commit> getCommits() {
 
     	return commits;
     }
-}
+}

src/main/java/knox/spring/data/neo4j/domain/Edge.java

@@ -555,7 +555,6 @@ public boolean hasOrientation() {
         return isInline() || isReverseComplement();
     }
 
-
     public boolean hasOrientation(Orientation orientation) {
         return hasOrientation() && this.orientation.equals(orientation);
     }

src/main/java/knox/spring/data/neo4j/operations/OROperator.java

@@ -17,4 +17,4 @@ public static void apply(List<NodeSpace> inputSpaces, NodeSpace outputSpace) {
 
 		outputSpace.shallowCopyNodeSpace(union.getSpace());
 	}
-}
+}

src/main/java/knox/spring/data/neo4j/operations/ReverseOperator.java

@@ -0,0 +1,22 @@
+package knox.spring.data.neo4j.operations;
+
+import knox.spring.data.neo4j.domain.Edge;
+import knox.spring.data.neo4j.domain.NodeSpace;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+public class ReverseOperator {
+	public static void apply(NodeSpace inputSpace, NodeSpace outputSpace) {
+		//copy input space to a new output space
+		outputSpace.copyNodeSpace(inputSpace);
+
+		Set<Edge> allEdges = outputSpace.getEdges();
+
+		//traverse all edges of input space and flip the orientation attribute
+		for(Edge edge: allEdges){
+			edge.reverseOrientation();
+		}
+	}
+}

src/main/java/knox/spring/data/neo4j/services/DesignSpaceService.java

@@ -13,6 +13,7 @@
 import knox.spring.data.neo4j.operations.JoinOperator;
 import knox.spring.data.neo4j.operations.MergeOperator;
 import knox.spring.data.neo4j.operations.OROperator;
+import knox.spring.data.neo4j.operations.ReverseOperator;
 import knox.spring.data.neo4j.operations.Product;
 import knox.spring.data.neo4j.operations.RepeatOperator;
 import knox.spring.data.neo4j.operations.Star;
@@ -325,7 +326,31 @@ public void mergeBranches(String targetSpaceID, List<String> inputBranchIDs,
 
         saveDesignSpace(targetSpace);
     }
-	
+
+	public void reverseDesignSpaces(String inputSpaceID) {
+		reverseDesignSpaces(inputSpaceID, inputSpaceID);
+	}
+
+	public void reverseDesignSpaces(String inputSpaceID, String outputSpaceID) {
+		List<String> inputSpaceIDs = new ArrayList<>();
+		inputSpaceIDs.add(inputSpaceID);
+		List<NodeSpace> inputSpaces = new ArrayList<NodeSpace>(inputSpaceIDs.size());
+
+		DesignSpace outputSpace = loadIOSpaces(inputSpaceIDs, outputSpaceID, inputSpaces);
+
+		ReverseOperator.apply(inputSpaces.get(0), outputSpace);
+
+
+		List<NodeSpace> inputSnaps = new ArrayList<NodeSpace>(inputSpaces.size());
+
+		NodeSpace outputSnap = mergeVersionHistories(castNodeSpacesToDesignSpaces(inputSpaces),
+				outputSpace, inputSnaps);
+
+		ReverseOperator.apply(inputSnaps.get(0), outputSnap);
+
+		saveDesignSpace(outputSpace);
+	}
+
 	private DesignSpace loadIOSpaces(List<String> inputSpaceIDs, String outputSpaceID,
     		List<NodeSpace> inputSpaces) {
     	for (String inputSpaceID : inputSpaceIDs) {
@@ -863,7 +888,8 @@ private DesignSpace findDesignSpace(String targetSpaceID) {
     }
 
 	private DesignSpace loadDesignSpace(String targetSpaceID) {
-		DesignSpace targetSpace = designSpaceRepository.findOne(getDesignSpaceGraphID(targetSpaceID), 3);
+		Long keyID = getDesignSpaceGraphID(targetSpaceID);
+		DesignSpace targetSpace = designSpaceRepository.findOne(keyID, 3);
 
 		for (Commit commit : targetSpace.getCommits()) {
 			commit.setSnapshot(reloadSnapshot(commit.getSnapshot()));

src/main/resources/static/gulpfile.js

@@ -103,4 +103,4 @@ gulp.task('dev', ['browserSync', 'less', 'minify-css', 'minify-js'], function()
     // Reloads the browser whenever HTML or JS files change
     gulp.watch('*.html', browserSync.reload);
     gulp.watch('js/**/*.js', browserSync.reload);
-});
+});

src/main/resources/static/js/endpoints.js

@@ -30,7 +30,8 @@ export const operators = {
   OR: 'or',
   AND: 'and',
   MERGE: 'merge',
-  REPEAT: 'repeat'
+  REPEAT: 'repeat',
+  REVERSE: 'reverse'
 };
 
 
@@ -288,4 +289,19 @@ export function designSpaceMerge(inputSpaces, outputSpace, tolerance){
   } else {
     swalError(request.response);
   }
+}
+
+export function designSpaceReverse(inputSpaces, outputSpace, tolerance){
+    let query = "?";
+    query += encodeQueryParameter("inputSpaceID", inputSpaces, query);
+    query += encodeQueryParameter("outputSpaceID", outputSpace, query);
+
+    let request = new XMLHttpRequest();
+    request.open("POST", endpoints.DESIGN + "/" + operators.REVERSE + query, false);
+    request.send(null);
+    if (request.status >= 200 && request.status < 300) {
+        swalSuccess();
+    } else {
+        swalError(request.response);
+    }
 }

src/main/resources/static/js/knox.js

@@ -557,6 +557,10 @@ $('#apply-operators-tooltip').click(() => {
         case endpoint.operators.MERGE:
           endpoint.designSpaceMerge(inputSpaces, outputSpace, tolerance);
           break;
+
+        case endpoint.operators.REVERSE:
+          endpoint.designSpaceReverse(inputSpaces, outputSpace);
+          break;
       }
     }
   });