org.aksw.jena_sparql_api.json.RdfJsonUtils Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jena-sparql-api-json Show documentation
The newest version!
package org.aksw.jena_sparql_api.json;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;

import org.apache.jena.geosparql.implementation.GeometryWrapper;
import org.apache.jena.graph.Node;
import org.apache.jena.query.QuerySolution;
import org.apache.jena.query.ResultSet;
import org.apache.jena.rdf.model.Property;
import org.apache.jena.rdf.model.RDFNode;
import org.apache.jena.rdf.model.Resource;
import org.apache.jena.rdf.model.Statement;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.io.ParseException;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.io.geojson.GeoJsonWriter;

import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonNull;
import com.google.gson.JsonObject;
import com.google.gson.JsonPrimitive;

public class RdfJsonUtils {
    public static JsonElement toJson(RDFNode rdfNode, int maxDepth, boolean flat) {
        JsonElement result = toJson(rdfNode, 0, maxDepth, flat);
        return result;
    }

    public static JsonObject toJson(Resource rdfNode, int maxDepth, boolean flat) {
        JsonElement tmp = toJson(rdfNode, 0, maxDepth, flat);
        JsonObject result = tmp.getAsJsonObject();
        return result;
    }

    public static JsonArray toJson(Collection rdfNodes, int maxDepth, boolean flat) {
        JsonArray result = new JsonArray();
        for(RDFNode rdfNode : rdfNodes) {
            JsonElement jsonElement = toJson(rdfNode, maxDepth, flat);
            result.add(jsonElement);
        }
        return result;

    }

    public static JsonArray toJson(ResultSet rs, int maxDepth, boolean flat) {
        JsonArray result = new JsonArray();
        List vars = rs.getResultVars();
        while(rs.hasNext()) {
            QuerySolution qs = rs.next();
            JsonObject row = toJson(qs, maxDepth, flat);
            if (flat && vars.size() == 1) {
                result.add(row.entrySet().iterator().next().getValue());
            } else {
                result.add(row);
            }
        }

        return result;
    }

    public static JsonObject toJson(QuerySolution qs, int maxDepth, boolean flat) {
        JsonObject row = new JsonObject();
        Iterator it = qs.varNames();
        while (it.hasNext()) {
            String varName = it.next();
            RDFNode rdfNode = qs.get(varName);
            JsonElement jsonElement = toJson(rdfNode, maxDepth, flat);
            row.add(varName, jsonElement);
        }

        return row;
    }

    public static JsonElement toJson(RDFNode rdfNode, int depth, int maxDepth, boolean flat) {
        JsonElement result;

        if(depth >= maxDepth) {
            // TODO We could add properties indicating that data was cut off here
            result = null; // new JsonObject();
        } else if(rdfNode == null) {
            result = JsonNull.INSTANCE;
        } else if(rdfNode.isLiteral()) {
            Node node = rdfNode.asNode();
            Object obj = node.getLiteralValue();
            //boolean isNumber =//NodeMapperRdfDatatype.canMapCore(node, Number.class);
            //if(isNumber) {
            if(obj instanceof String) {
                String value = (String)obj;
                result = new JsonPrimitive(value);
            } else if(obj instanceof Number) {
                Number value = (Number)obj; //NodeMapperRdfDatatype.toJavaCore(node, Number.class);
//				Literal literal = rdfNode.asLiteral();
                result = new JsonPrimitive(value);
            } else if(obj instanceof Boolean) {
                Boolean value = (Boolean) obj;
                result = new JsonPrimitive(value);
            } else if(obj instanceof GeometryWrapper) {
                WKTReader wktReader = new WKTReader();
                try {
                    final Geometry geom = wktReader.read(rdfNode.asLiteral().getLexicalForm());

                    GeoJsonWriter geoJsonWriter = new GeoJsonWriter();
                    String jsonString = geoJsonWriter.write(geom);
                    Gson gson = new Gson();
                    result = gson.fromJson(jsonString, JsonObject.class);
                } catch (ParseException e) {
                    throw new RuntimeException("Invalid WKT : " + rdfNode);
                }
            } else {

                String value = rdfNode.asLiteral().getLexicalForm() ; // Objects.toString(obj);
                result = new JsonPrimitive(value ) ; //+ "^^" + obj.getClass().getCanonicalName());
//				throw new RuntimeException("Unsupported literal: " + rdfNode);
            }
        } else if(rdfNode.isResource()) {
            JsonObject tmp = new JsonObject();
            Resource r = rdfNode.asResource();

            if(r.isURIResource()) {
                tmp.addProperty("id", r.getURI());
                tmp.addProperty("id_type", "uri");
            } else if(r.isAnon()) {
                tmp.addProperty("id", r.getId().getLabelString());
                tmp.addProperty("id_type", "bnode");
            }

            List stmts = r.listProperties().toList();



            Map> pos = stmts.stream()
                    .collect(Collectors.groupingBy(Statement::getPredicate,
                            Collectors.mapping(Statement::getObject, Collectors.toList())));

            for(Entry> e : pos.entrySet()) {
                JsonArray arr = new JsonArray();
                Property p = e.getKey();
                String k = p.getLocalName();

                for(RDFNode o : e.getValue()) {
                    JsonElement v = toJson(o, depth + 1, maxDepth, flat);
                    if (v != null)
                    arr.add(v);
                }

                if (arr.size() > 0) {
                    if (flat && arr.size() == 1)
                        tmp.add(k, arr.get(0));
                    else
                        tmp.add(k, arr);
                }
            }
            result = tmp;
        } else {
            throw new RuntimeException("Unknown node type: " + rdfNode);
        }

        return result;
    }
}