[DD-1002] records deprecation endpoint

Author: Thomas Gängler

src/main/java/org/dswarm/graph/delta/util/GraphDBUtil.java

@@ -1253,12 +1253,13 @@ private static String buildGetRecordUriQuery(
 		// RETURN n.uri;
 
 		final StringBuilder sb = new StringBuilder();
-		sb.append("MATCH (o:").append(NodeType.Literal).append(" {").append(GraphStatics.VALUE_PROPERTY).append(":\"").append(recordId).append("\"})\n")
+		sb.append("MATCH (o:").append(NodeType.Literal).append(" {").append(GraphStatics.VALUE_PROPERTY).append(":\"").append(recordId)
+				.append("\"})\n")
 				.append("WITH o\n")
 				.append("MATCH (o)");
 
 		final List<Attribute> attributes = prefixedRecordIdentifierAP.getAttributes();
-		int i = attributes.size() -1;
+		int i = attributes.size() - 1;
 
 		while (i >= 0) {
 
@@ -1289,12 +1290,13 @@ private static String buildGetRecordUrisQuery(final String searchValue, final At
 			throws DMPGraphException {
 
 		final StringBuilder sb = new StringBuilder();
-		sb.append("MATCH (o:").append(NodeType.Literal).append(" {").append(GraphStatics.VALUE_PROPERTY).append(":\"").append(searchValue).append("\"})\n")
+		sb.append("MATCH (o:").append(NodeType.Literal).append(" {").append(GraphStatics.VALUE_PROPERTY).append(":\"").append(searchValue)
+				.append("\"})\n")
 				.append("WITH o\n")
 				.append("MATCH (o)");
 
 		final List<Attribute> attributes = prefixedKeyAttributePath.getAttributes();
-		int i = attributes.size() -1;
+		int i = attributes.size() - 1;
 
 		while (i >= 0) {
 

src/main/java/org/dswarm/graph/deprecate/RecordsNeo4jDeprecator.java

@@ -0,0 +1,165 @@
+/**
+ * This file is part of d:swarm graph extension.
+ *
+ * d:swarm graph extension is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * d:swarm graph extension is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with d:swarm graph extension.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.dswarm.graph.deprecate;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Optional;
+
+import org.neo4j.graphdb.GraphDatabaseService;
+import org.neo4j.graphdb.Node;
+import org.neo4j.graphdb.Result;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.dswarm.graph.BasicNeo4jProcessor;
+import org.dswarm.graph.DMPGraphException;
+import org.dswarm.graph.NodeType;
+import org.dswarm.graph.model.GraphStatics;
+import org.dswarm.graph.versioning.DataModelNeo4jVersionHandler;
+
+/**
+ * @author tgaengler
+ */
+public class RecordsNeo4jDeprecator extends BaseNeo4jDeprecator {
+
+	private static final Logger LOG = LoggerFactory.getLogger(RecordsNeo4jDeprecator.class);
+	public static final String RECORD_VARIABLE = "record";
+
+	private final String             prefixedDataModelUri;
+	private final Collection<String> prefixedRecordURIs;
+
+	public RecordsNeo4jDeprecator(final BasicNeo4jProcessor processorArg, final boolean enableVersioningArg, final String prefixedDataModelUriArg,
+			final Collection<String> prefixedRecordURIsArg)
+			throws DMPGraphException {
+
+		super(processorArg, enableVersioningArg);
+
+		prefixedDataModelUri = prefixedDataModelUriArg;
+		prefixedRecordURIs = prefixedRecordURIsArg;
+	}
+
+	@Override
+	protected void init() throws DMPGraphException {
+
+		versionHandler = new DataModelNeo4jVersionHandler(processor, enableVersioning);
+		version = versionHandler.getLatestVersion();
+		previousVersion = version - 1;
+	}
+
+	@Override public void work() throws DMPGraphException {
+
+		LOG.debug("try to deprecate some records in data model '{}'", prefixedDataModelUri);
+
+		processor.ensureRunningTx();
+
+		final GraphDatabaseService database = processor.getDatabase();
+
+		for (final String prefixedRecordURI : prefixedRecordURIs) {
+
+			final Optional<Node> optionalRecord = getRecord(database, prefixedRecordURI);
+
+			if(!optionalRecord.isPresent()) {
+
+				continue;
+			}
+
+			final Node record = optionalRecord.get();
+
+			startNodeHandler.handleNode(record);
+		}
+
+		LOG.debug("finished deprecating some records in data model '{}'", prefixedDataModelUri);
+	}
+
+	private Optional<Node> getRecord(final GraphDatabaseService database, final String prefixedRecordURI) {
+
+		final String query = buildQuery(prefixedRecordURI);
+
+		final Result result = database.execute(query);
+
+		return evaluateSingleNodeResult(prefixedRecordURI, result);
+	}
+
+	private Optional<Node> evaluateSingleNodeResult(String prefixedRecordURI, Result result) {
+
+		if(result == null) {
+
+			LOG.error("couldn't retrieve record for uri '{}'", prefixedRecordURI);
+
+			return Optional.empty();
+		}
+
+		if (!result.hasNext()) {
+
+			result.close();
+
+			LOG.error("couldn't find record for uri '{}'", prefixedRecordURI);
+
+			return Optional.empty();
+		}
+
+		final Map<String, Object> row = result.next();
+
+		final Iterator<Map.Entry<String, Object>> rowIter = row.entrySet().iterator();
+
+		if (!rowIter.hasNext()) {
+
+			result.close();
+
+			LOG.error("couldn't find record for uri '{}'", prefixedRecordURI);
+
+			return Optional.empty();
+		}
+
+		final Map.Entry<String, Object> column = rowIter.next();
+
+		if (column.getValue() == null) {
+
+			result.close();
+
+			LOG.error("couldn't find record for uri '{}'", prefixedRecordURI);
+
+			return Optional.empty();
+		}
+
+		if (!column.getKey().equals(RECORD_VARIABLE) || !Node.class.isInstance(column.getValue())) {
+
+			result.close();
+
+			return Optional.empty();
+		}
+
+		final Node record = (Node) column.getValue();
+
+		result.close();
+
+		return Optional.ofNullable(record);
+	}
+
+	private String buildQuery(final String prefixedRecordURI) {
+
+		final StringBuilder sb = new StringBuilder();
+
+		sb.append("MATCH ").append("(n:").append(NodeType.Resource).append(" {").append(GraphStatics.URI_PROPERTY).append(" : \"").append(prefixedRecordURI).append("\"})\n")
+				.append("WHERE n.").append(GraphStatics.DATA_MODEL_PROPERTY).append(" = \"").append(prefixedDataModelUri).append("\"\n")
+				.append("RETURN n AS ").append(RECORD_VARIABLE);
+
+		return sb.toString();
+	}
+}

src/main/java/org/dswarm/graph/resources/MaintainResource.java

@@ -20,6 +20,8 @@
 import java.io.IOException;
 import java.io.StringWriter;
 import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -37,6 +39,7 @@
 
 import com.fasterxml.jackson.core.JsonGenerator;
 import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.google.common.base.Charsets;
 import com.google.common.base.Optional;
@@ -61,6 +64,7 @@
 import org.dswarm.graph.GraphIndexStatics;
 import org.dswarm.graph.GraphProcessingStatics;
 import org.dswarm.graph.deprecate.DataModelNeo4jDeprecator;
+import org.dswarm.graph.deprecate.RecordsNeo4jDeprecator;
 import org.dswarm.graph.deprecate.RelationshipDeprecator;
 import org.dswarm.graph.index.MapDBUtils;
 import org.dswarm.graph.index.NamespaceIndex;
@@ -87,6 +91,8 @@ public class MaintainResource extends GraphResource {
 
 	private static final String DEPRECATE_DATA_MODEL_TYPE = "deprecate data model";
 
+	private static final String DEPRECATE_RECORDS_TYPE = "deprecate records";
+
 	public MaintainResource() {
 
 	}
@@ -121,19 +127,19 @@ public Response deprecateDataModel(final String jsonObjectString, @Context final
 
 		final BasicNeo4jProcessor processor = new DataModelNeo4jProcessor(database, tx, namespaceIndex, prefixedDataModelUri);
 
-		final RelationshipDeprecator statementDeprecator = new DataModelNeo4jDeprecator(processor, true, prefixedDataModelUri);
+		final RelationshipDeprecator dataModelDeprecator = new DataModelNeo4jDeprecator(processor, true, prefixedDataModelUri);
 
-		statementDeprecator.work();
+		dataModelDeprecator.work();
 
-		final int relationshipsDeprecated = statementDeprecator.getRelationshipsDeprecated();
+		final int relationshipsDeprecated = dataModelDeprecator.getRelationshipsDeprecated();
 
 		if (relationshipsDeprecated > 0) {
 
 			// update data model version only when some statements are deprecated the DB
-			statementDeprecator.getVersionHandler().updateLatestVersion();
+			dataModelDeprecator.getVersionHandler().updateLatestVersion();
 		}
 
-		statementDeprecator.closeTransaction();
+		dataModelDeprecator.closeTransaction();
 
 		LOG.info("deprecated '{}' relationships in data model '{}' ('{}') in graph db", relationshipsDeprecated, dataModelUri, prefixedDataModelUri);
 
@@ -144,6 +150,57 @@ public Response deprecateDataModel(final String jsonObjectString, @Context final
 		return Response.ok(result, MediaType.APPLICATION_JSON_TYPE).build();
 	}
 
+	@POST
+	@Path("/deprecate/records")
+	@Consumes(MediaType.APPLICATION_JSON)
+	@Produces(MediaType.APPLICATION_JSON)
+	public Response deprecateRecords(final String jsonObjectString, @Context final GraphDatabaseService database) throws DMPGraphException {
+
+		MaintainResource.LOG.info("try to deprecate records in a data model in graph db");
+
+		final ObjectNode requestJSON = deserializeJSON(jsonObjectString, DEPRECATE_RECORDS_TYPE);
+
+		final String dataModelUri = requestJSON.get(DMPStatics.DATA_MODEL_URI_IDENTIFIER).asText();
+
+		final Collection<String> recordURIs = getRecordURIs(requestJSON);
+
+		final TransactionHandler tx = new Neo4jTransactionHandler(database);
+		final NamespaceIndex namespaceIndex = new NamespaceIndex(database, tx);
+
+		final String prefixedDataModelUri = namespaceIndex.createPrefixedURI(dataModelUri);
+
+		final Collection<String> prefixedRecordURIs = prefixRecordURIs(recordURIs, namespaceIndex);
+
+		MaintainResource.LOG.info("try to deprecate '{}' records in data model '{}' ('{}') in graph db", prefixedRecordURIs.size(), dataModelUri,
+				prefixedDataModelUri);
+
+		final BasicNeo4jProcessor processor = new DataModelNeo4jProcessor(database, tx, namespaceIndex, prefixedDataModelUri);
+
+		final RelationshipDeprecator recordsDeprecator = new RecordsNeo4jDeprecator(processor, true, prefixedDataModelUri, prefixedRecordURIs);
+
+		recordsDeprecator.work();
+
+		final int relationshipsDeprecated = recordsDeprecator.getRelationshipsDeprecated();
+
+		if (relationshipsDeprecated > 0) {
+
+			// update data model version only when some statements are deprecated the DB
+			recordsDeprecator.getVersionHandler().updateLatestVersion();
+		}
+
+		recordsDeprecator.closeTransaction();
+
+		LOG.info("deprecated '{}' records with '{}' relationships in data model '{}' ('{}') in graph db", prefixedRecordURIs.size(),
+				relationshipsDeprecated, dataModelUri, prefixedDataModelUri);
+
+		final ObjectNode resultJSON = simpleObjectMapper.createObjectNode();
+		resultJSON.put("deprecated", relationshipsDeprecated);
+		final String result = serializeJSON(resultJSON, DEPRECATE_DATA_MODEL_TYPE);
+
+		return Response.ok(result, MediaType.APPLICATION_JSON_TYPE).build();
+
+	}
+
 	/**
 	 * note utilise this endpoint with care, because it cleans your complete db!
 	 *
@@ -512,4 +569,34 @@ private void initPrefixes(final GraphDatabaseService database) throws DMPGraphEx
 
 		MaintainResource.LOG.debug("finished initialising namespaces index");
 	}
+
+	private Collection<String> getRecordURIs(final ObjectNode json) {
+
+		final JsonNode recordsNode = json.get(DMPStatics.RECORDS_IDENTIFIER);
+
+		final ArrayList<String> recordURIs = new ArrayList<>();
+
+		for (final JsonNode recordNode : recordsNode) {
+
+			final String recordURI = recordNode.asText();
+
+			recordURIs.add(recordURI);
+		}
+
+		return recordURIs;
+	}
+
+	private Collection<String> prefixRecordURIs(final Collection<String> recordURIs, final NamespaceIndex namespaceIndex) throws DMPGraphException {
+
+		final ArrayList<String> prefixedRecordURIs = new ArrayList<>();
+
+		for (final String recordURI : recordURIs) {
+
+			final String prefixedRecordURI = namespaceIndex.createPrefixedURI(recordURI);
+
+			prefixedRecordURIs.add(prefixedRecordURI);
+		}
+
+		return prefixedRecordURIs;
+	}
 }