Not yet working on collections of blank nodes, as the group_concat fails

Author: Matthias Böckmann

dataformat-jsonld/src/main/java/io/adminshell/aas/v3/dataformat/jsonld/Parser.java

@@ -22,8 +22,10 @@
 import java.lang.reflect.*;
 import java.math.BigDecimal;
 import java.math.BigInteger;
+import java.net.MalformedURLException;
 import java.net.URI;
 import java.net.URISyntaxException;
+import java.net.URL;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.time.ZonedDateTime;
@@ -39,6 +41,8 @@ class Parser {
 
     private final Logger logger = LoggerFactory.getLogger(Parser.class);
 
+    private static final URI blankNodeIdPropertyUri = URI.create("https://admin-shell.io/aas/blankNodeId");
+
     static Map<String, String> knownNamespaces = new HashMap<>();
 
     /**
@@ -55,20 +59,30 @@ private <T> T handleObject(Model inputModel, String objectUri, Class<T> targetCl
 
             //if(!targetClass.getSimpleName().endsWith("Impl")) //This would not work for "TypedLiteral", "RdfResource" and so on
             //Check whether we are dealing with an instantiable class (i.e. no interface and no abstract class)
+            boolean currentObjectIsBlankNode = false;
             if (targetClass.isInterface() || Modifier.isAbstract(targetClass.getModifiers())) {
                 //We don't know the desired class yet (current targetClass is not instantiable). This is only known for the root object
                 ArrayList<Class<?>> implementingClasses = getImplementingClasses(targetClass);
-
+                String queryString;
                 //Get a list of all "rdf:type" statements in our model
                 //In case of a blank node, the "object URI" will just be a string and no valid URI. In that  case, we need a different query syntax
                 try {
-                    new URI(objectUri).toURL();
+                    new URL(objectUri);
                 }
-                catch (URISyntaxException | IllegalArgumentException e)
+                catch (MalformedURLException e)
                 {
-                    e.printStackTrace();
+                    currentObjectIsBlankNode = true;
+                }
+                if(currentObjectIsBlankNode)
+                {
+                    //Object is a blank node, so the subject URI cannot be used
+                    queryString = "SELECT ?type { ?s <" + blankNodeIdPropertyUri + "> \"" + objectUri + "\" ; a ?type . }";
+                }
+                else
+                {
+                    //Not a blank node, so we can work with the subject URI
+                    queryString = "SELECT ?type { BIND(<" + objectUri + "> AS ?s). ?s a ?type . }";
                 }
-                String queryString = "SELECT ?type { BIND(<" + objectUri + "> AS ?s). ?s a ?type . }";
                 Query query = QueryFactory.create(queryString);
                 QueryExecution queryExecution = QueryExecutionFactory.create(query, inputModel);
                 ResultSet resultSet = queryExecution.execSelect();
@@ -215,9 +229,19 @@ private <T> T handleObject(Model inputModel, String objectUri, Class<T> targetCl
             //Start the "WHERE" part - Fuseki does not expect the "WHERE" keyword, but just an "{"
             queryStringBuilder.append(" { ");
 
+            //In case of blank nodes, we can't work with the subject URI
+            if(currentObjectIsBlankNode)
+            {
+                queryStringBuilder.append("?s <").append(blankNodeIdPropertyUri).append("> \"").append(objectUri).append("\" ;");
+            }
+            else
+            {
+                queryStringBuilder.append(" <").append(objectUri).append(">");
+            }
+
             //Make sure that the object is of the correct type
             //This is particularly relevant in case of all fields being optional -- then one could simply parse a random object
-            queryStringBuilder.append(" <").append(objectUri).append("> a ").append(wrapIfUri(targetClass.getAnnotation(IRI.class).value()[0])).append(". ");
+            queryStringBuilder.append(" a ").append(wrapIfUri(targetClass.getAnnotation(IRI.class).value()[0])).append(". ");
 
             for (Map.Entry<String, Method> entry : methodMap.entrySet()) {
                 //Is this a field which is annotated by NOT NULL?
@@ -229,7 +253,13 @@ private <T> T handleObject(Model inputModel, String objectUri, Class<T> targetCl
                 //In AAS, every field is optional, as there are no validation annotations in the model
                 queryStringBuilder.append(" OPTIONAL {");
 
-                queryStringBuilder.append(" <").append(objectUri).append("> "); //subject, as passed to the function
+                if(currentObjectIsBlankNode)
+                {
+                    queryStringBuilder.append(" ?s ");
+                }
+                else {
+                    queryStringBuilder.append(" <").append(objectUri).append("> "); //subject, as passed to the function
+                }
                 //For the field, get the JsonAlias annotation (present for all classes generated by the CodeGen tool)
                 //Find the annotation value containing a colon and interpret this as "prefix:predicate"
                 boolean foundAnnotation = false;
@@ -276,13 +306,6 @@ private <T> T handleObject(Model inputModel, String objectUri, Class<T> targetCl
                     queryForOtherProperties.append(" <").append(entry.getValue()).append(">\n");
                 }
 
-                for (Map.Entry<String, String> entry : knownNamespaces.entrySet()) {
-                    queryForOtherProperties.append("PREFIX ").append(entry.getKey());
-                    if (!entry.getKey().endsWith(":")) {
-                        queryForOtherProperties.append(":");
-                    }
-                    queryForOtherProperties.append(" <").append(entry.getValue()).append(">\n");
-                }
 
                 //Respect ALL properties and values
                 queryForOtherProperties.append(" SELECT ?p ?o {  <").append(objectUri).append("> ?p ?o .\n");
@@ -442,13 +465,48 @@ private <T> T handleObject(Model inputModel, String objectUri, Class<T> targetCl
                     if (Collection.class.isAssignableFrom(currentType)) {
                         sparqlParameterName += "s"; //plural form for the concatenated values
                     }
-                    if (querySolution.contains(sparqlParameterName)) {
+                    querySolution.varNames().forEachRemaining(System.out::println);
+                    System.out.println(querySolution.contains(sparqlParameterName));
+                    if (querySolution.contains(sparqlParameterName)) { //TODO why is this false for keys?! Answer: Because you can't do a GROUP_CONCAT on blank nodes
                         String currentSparqlBinding = querySolution.get(sparqlParameterName).toString();
+
                         boolean objectIsBlankNode = querySolution.get(sparqlParameterName).isResource() && querySolution.get(sparqlParameterName).asNode().isBlank();
-                        System.out.println(currentSparqlBinding + " is blank node? " + objectIsBlankNode);
+                        String blankNodeId = "";
+                        //If the object is a blank node, we will struggle to make follow-up queries starting at the blank node as subject
+                        //For that case, we add some artificial identifiers here
+                        if(objectIsBlankNode) {
+                            blankNodeId = querySolution.get(sparqlParameterName).asNode().getBlankNodeId().toString();
+                            inputModel.add(
+                                ResourceFactory.createStatement(
+                                        querySolution.get(sparqlParameterName).asResource(), //subject: the blank node
+                                        ResourceFactory.createProperty(blankNodeIdPropertyUri.toString()), //some artificial property
+                                        ResourceFactory.createStringLiteral(blankNodeId))); //object: the ID of the blank node
+                        }
 
                         if (currentType.isEnum()) {
-                            entry.getValue().invoke(returnObject, handleEnum(currentType, currentSparqlBinding));
+                            //Two possibilities:
+                            //1: The URI of the enum value is given directly e.g. ?s ?p <someUri>
+                            //2: The URI of the enum value is encapsulated in a blank node, e.g.
+                            //  ?s ?p [ a demo:myEnum, demo:enumValue ]
+                            if(objectIsBlankNode)
+                            {
+                                Query innerEnumQuery = QueryFactory.create("SELECT ?type { ?s <" + blankNodeIdPropertyUri + "> + \"" + blankNodeId + "\" ; a ?type } ");
+                                QueryExecution innerEnumQueryExecution = QueryExecutionFactory.create(innerEnumQuery, inputModel);
+                                ResultSet innerEnumQueryExecutionResultSet = innerEnumQueryExecution.execSelect();
+                                while(innerEnumQueryExecutionResultSet.hasNext())
+                                {
+                                    try {
+                                        entry.getValue().invoke(returnObject, handleEnum(currentType, innerEnumQueryExecutionResultSet.next().get("type").toString()));
+                                        break; //Stop after the first successful execution
+                                    }
+                                    catch (IOException ignored) //There might be errors, if multiple types are present, see example above
+                                    {}
+                                }
+                                innerEnumQueryExecution.close();
+                            }
+                            else {
+                                entry.getValue().invoke(returnObject, handleEnum(currentType, currentSparqlBinding));
+                            }
                             continue;
                         }
 
@@ -527,7 +585,13 @@ private <T> T handleObject(Model inputModel, String objectUri, Class<T> targetCl
 
                             } else {
                                 //Not a primitive object, but a complex sub-object. Recursively call this function to handle it
-                                entry.getValue().invoke(returnObject, handleObject(inputModel, currentSparqlBinding, entry.getValue().getParameterTypes()[0]));
+                                if (objectIsBlankNode) {
+                                    System.out.println("Handling sub-object as blank node");
+                                    entry.getValue().invoke(returnObject, handleObject(inputModel, blankNodeId, entry.getValue().getParameterTypes()[0]));
+                                } else {
+
+                                    entry.getValue().invoke(returnObject, handleObject(inputModel, currentSparqlBinding, entry.getValue().getParameterTypes()[0]));
+                                }
                             }
                         }
                     }
@@ -690,7 +754,7 @@ private <T> T handleEnum(Class<T> enumClass, String url) throws IOException {
             url = url.substring(url.lastIndexOf("/") + 1);
         }
         for (T constant : constants) {
-            if (url.equals(constant.toString())) {
+            if (url.equalsIgnoreCase(constant.toString())) {
                 return constant;
             }
         }

dataformat-jsonld/src/test/java/io/adminshell/aas/v3/model/dataformat/jsonld/ParserTest.java

@@ -62,6 +62,10 @@ public void parseAllSchemaExamplesTest() throws IOException, DeserializationExce
             }
         }
         Assert.assertEquals(0, errorCtr);
+
+
+        AssetAdministrationShell aas = serializer.deserialize(SerializerUtil.readResourceToString("AAS_Reference_shortExample.ttl"), AssetAdministrationShell.class);
+        System.out.println(serializer.serialize(aas));
     }
 
 }