Merge pull request #754 from bserdar/any-support

paterczm · web-flow · commit feafa4be1119 · 2017-01-19T09:34:42.000-05:00
Fix #753: add any type, unsearchable free-form json data
diff --git a/metadata/src/main/java/com/redhat/lightblue/metadata/types/AnyType.java b/metadata/src/main/java/com/redhat/lightblue/metadata/types/AnyType.java
@@ -0,0 +1,107 @@
+/*
+ Copyright 2013 Red Hat, Inc. and/or its affiliates.
+
+ This file is part of lightblue.
+
+ This program 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.
+
+ This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.redhat.lightblue.metadata.types;
+
+import java.io.Serializable;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+
+import com.redhat.lightblue.metadata.Type;
+import com.redhat.lightblue.metadata.MetadataConstants;
+
+import com.redhat.lightblue.util.JsonUtils;
+
+public final class AnyType implements Type, Serializable {
+    
+    private static final long serialVersionUID = 1l;
+
+    public static final Type TYPE = new AnyType();
+    public static final String NAME = "any";
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public boolean supportsEq() {
+        return false;
+    }
+
+    @Override
+    public boolean supportsOrdering() {
+        return false;
+    }
+
+    @Override
+    public JsonNode toJson(JsonNodeFactory factory, Object obj) {
+        return JsonUtils.toJson(obj);
+    }
+    
+    @Override
+    public Object fromJson(JsonNode node) {
+        return JsonUtils.fromJson(node);
+    }
+
+    @Override
+    public Object cast(Object obj) {
+        if (obj == null) {
+            return null;
+        } else if (obj instanceof JsonNode) {
+            return fromJson((JsonNode)obj);
+        } else {
+            return obj;
+        }
+    }
+    
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    @Override
+    public int compare(Object v1, Object v2) {
+        if (v1 == null) {
+            if (v2 == null) {
+                return 0;
+            } else {
+                return -1;
+            }
+        } else if (v2 == null) {
+            return 1;
+        } else {
+            throw new UnsupportedOperationException(MetadataConstants.ERR_COMPARE_NOT_SUPPORTED);
+        }
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        return obj instanceof AnyType;
+    }
+
+    @Override
+    public int hashCode() {
+        return NAME.hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return NAME;
+    }
+
+    private AnyType() {
+    }
+}
diff --git a/metadata/src/main/java/com/redhat/lightblue/metadata/types/DefaultTypes.java b/metadata/src/main/java/com/redhat/lightblue/metadata/types/DefaultTypes.java
@@ -46,6 +46,7 @@ public DefaultTypes() {
         typeMap.put(ArrayType.NAME, ArrayType.TYPE);
         typeMap.put(ObjectType.NAME, ObjectType.TYPE);
         typeMap.put(ReferenceType.NAME, ReferenceType.TYPE);
+        typeMap.put(AnyType.NAME, AnyType.TYPE);
         typeMap.put(UIDType.NAME, UIDType.TYPE);
     }
 }
diff --git a/util/src/main/java/com/redhat/lightblue/util/JsonUtils.java b/util/src/main/java/com/redhat/lightblue/util/JsonUtils.java
@@ -24,9 +24,18 @@
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.Reader;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
 import java.nio.charset.Charset;
+
 import java.util.Iterator;
 import java.util.Map;
+import java.util.Collection;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
 
 import org.apache.commons.lang3.text.StrSubstitutor;
 
@@ -36,6 +45,12 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import com.fasterxml.jackson.databind.node.ValueNode;
+import com.fasterxml.jackson.databind.node.NullNode;
+import com.fasterxml.jackson.databind.node.TextNode;
+import com.fasterxml.jackson.databind.node.BooleanNode;
+import com.fasterxml.jackson.databind.node.NumericNode;
 import com.github.fge.jsonschema.core.exceptions.ProcessingException;
 import com.github.fge.jsonschema.core.report.ProcessingMessage;
 import com.github.fge.jsonschema.core.report.ProcessingReport;
@@ -108,6 +123,126 @@ public static JsonNode json(Reader reader, boolean systemPropertySubstitution) t
         return json(bld.toString(), systemPropertySubstitution);
     }
 
+    /**
+     * Returns a Java object for a json value node based on the node type.
+     */
+    public static Object valueFromJson(ValueNode node) {
+        if (node instanceof NullNode) {
+            return null;
+        } else {
+            if(node instanceof TextNode) {
+                return node.textValue();
+            } else if(node instanceof BooleanNode) {
+                return node.booleanValue();
+            } else if(node instanceof NumericNode) {
+                return node.numberValue();
+            } else {
+                throw new RuntimeException("Unsupported node type:"+node.getClass().getName());
+            }
+        }
+    }
+
+    /**
+     * Returns a Json value node for the given value. Dates are converted to strings
+     */
+    public static ValueNode valueToJson(Object value) {
+        if(value==null) {
+            return JsonNodeFactory.instance.nullNode();
+        } else if(value instanceof String) {
+            return JsonNodeFactory.instance.textNode((String)value);
+        } else if(value instanceof Number) {
+            if (value instanceof BigDecimal) {
+                return JsonNodeFactory.instance.numberNode((BigDecimal) value);
+            } else if (value instanceof BigInteger) {
+                return JsonNodeFactory.instance.numberNode((BigInteger) value);
+            } else if (value instanceof Double) {
+                return JsonNodeFactory.instance.numberNode((Double) value);
+            } else if (value instanceof Float) {
+                return JsonNodeFactory.instance.numberNode((Float) value);
+            } else if (value instanceof Long) {
+                return JsonNodeFactory.instance.numberNode((Long) value);
+            } else {
+                return JsonNodeFactory.instance.numberNode( ((Number)value).intValue());
+            }
+        } else if(value instanceof Boolean) {
+            return JsonNodeFactory.instance.booleanNode( ((Boolean)value).booleanValue());
+        } else if(value instanceof Date) {
+            return JsonNodeFactory.instance.textNode(Constants.getDateFormat().format((Date)value));
+        } else {
+            return JsonNodeFactory.instance.textNode(value.toString());
+        }            
+    }
+
+    /**
+     * Converts a json document to an object tree of maps/lists/values
+     *
+     * If json is a value, then the corresponding Java object is returned.
+     *
+     * If json is an array, a List is returned. Elements of the list are converted recursively
+     *
+     * If json is an object, a Map is returned.
+     */
+    public static Object fromJson(JsonNode json) {
+        if(json==null||json instanceof NullNode) {
+            return null;
+        } else if(json instanceof ObjectNode) {
+            return fromJson((ObjectNode)json);
+        } else if(json instanceof ArrayNode) {
+            return fromJson((ArrayNode)json);
+        } else {
+            return valueFromJson( (ValueNode)json);
+        }
+    }
+
+    private static Object fromJson(ObjectNode json) {
+        HashMap ret=new HashMap();
+        for(Iterator<Map.Entry<String,JsonNode>> itr=json.fields();itr.hasNext();) {
+            Map.Entry<String,JsonNode> entry=itr.next();
+            ret.put(entry.getKey(),fromJson(entry.getValue()));
+        }
+        return ret;
+    }
+
+    private static Object fromJson(ArrayNode json) {
+        ArrayList ret=new ArrayList(json.size());
+        for(Iterator<JsonNode> itr=json.elements();itr.hasNext();) {
+            ret.add(fromJson(itr.next()));
+        }
+        return ret;
+    }
+
+    /**
+     * Converts a Java object tree containing maps and collections to json
+     */
+    public static JsonNode toJson(Object obj) {
+        if(obj==null) {
+            return JsonNodeFactory.instance.nullNode();
+        } else if(obj instanceof Map) {
+            return toJson( (Map)obj );
+        } else if(obj instanceof Collection) {
+            return toJson( (Collection)obj);
+        } else {
+            return valueToJson(obj);
+        }
+    }
+
+    private static JsonNode toJson(Map obj) {
+        ObjectNode node=JsonNodeFactory.instance.objectNode();
+        for(Iterator<Map.Entry> itr=obj.entrySet().iterator();itr.hasNext();) {
+            Map.Entry entry=itr.next();
+            node.set((String)entry.getKey(),toJson(entry.getValue()));
+        }
+        return node;
+    }
+
+    private static JsonNode toJson(Collection obj) {
+        ArrayNode node=JsonNodeFactory.instance.arrayNode();
+        for(Object x:obj) {
+            node.add(toJson(x));
+        }
+        return node;
+    }
+
     /**
      * Pretty print a json doc
      */
diff --git a/util/src/test/java/com/redhat/lightblue/util/JsonUtilsTest.java b/util/src/test/java/com/redhat/lightblue/util/JsonUtilsTest.java
@@ -18,6 +18,11 @@
  */
 package com.redhat.lightblue.util;
 
+import java.util.Map;
+import java.util.List;
+import java.util.HashMap;
+import java.util.ArrayList;
+
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.JsonNodeFactory;
@@ -120,4 +125,29 @@ public void testJsonWithInvalidJSONInput() throws Exception {
         // TODO review the generated test code and remove the default call to fail.
         fail("The test case is a prototype.");
     }
+
+    @Test
+    public void testFromJson() throws Exception {
+        JsonNode node=JsonUtils.json(getClass().getResourceAsStream("/JsonNodeDocTest-complex.json"));
+        Map obj=(Map)JsonUtils.fromJson(node);
+        Assert.assertTrue(obj.get("object1") instanceof Map);
+        Assert.assertTrue(obj.get("object2") instanceof Map);
+        Assert.assertEquals("value3",((Map)obj.get("object2")).get("simple3"));
+        Assert.assertEquals(2,((List) ((Map)obj.get("object1")).get("array1")).size());
+        Assert.assertEquals("value1",((Map)((List)((Map)obj.get("object1")).get("array1")).get(0)).get("simple1"));
+    }
+    
+    @Test
+    public void testToson() throws Exception {
+        HashMap m=new HashMap();
+        m.put("v1","value1");
+        HashMap n;
+        m.put("o",n=new HashMap());
+        List a=new ArrayList();
+        n.put("a",a);
+        a.add(new Integer(1));
+        JsonNode node=JsonUtils.toJson(m);
+        Assert.assertEquals("value1",node.get("v1").asText());
+        Assert.assertEquals(1,node.get("o").get("a").get(0).asInt());
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -46,6 +46,7 @@ public DefaultTypes() {`
`46`	`46`	`typeMap.put(ArrayType.NAME, ArrayType.TYPE);`
`47`	`47`	`typeMap.put(ObjectType.NAME, ObjectType.TYPE);`
`48`	`48`	`typeMap.put(ReferenceType.NAME, ReferenceType.TYPE);`
	`49`	`+ typeMap.put(AnyType.NAME, AnyType.TYPE);`
`49`	`50`	`typeMap.put(UIDType.NAME, UIDType.TYPE);`
`50`	`51`	`}`
`51`	`52`	`}`