Os VT 2 - Providers implemented

src/main/java/io/opensaber/views/EvaluatorFactory.java

@@ -0,0 +1,42 @@
+package io.opensaber.views;
+
+import java.util.List;
+
+public class EvaluatorFactory {
+
+    /**
+     * returns the instance of IEvaluator implementations (like:FunctionEvaluator, ProviderEvaluator 
+     * 
+     * @param actualValues
+     * @param functiondef
+     * @return
+     */
+    public static IEvaluator<Object> getInstance(FunctionDefinition functiondef, List<Object> actualValues) {
+        IEvaluator<Object> evaluator = null;
+        FieldFunction function = null;
+
+        if (functiondef.getResult() != null) {
+            function = getFieldFunction(functiondef.getResult(), actualValues);
+            evaluator = new FunctionEvaluator(function);
+
+        } else if (functiondef.getProvider() != null) {
+            function = getFieldFunction(functiondef.getProvider(), actualValues);
+            evaluator = new ProviderEvaluator(function);
+        }
+
+        return evaluator;
+    }
+    /**
+     * Creates FieldFunction and sets argValues
+     * @param expression
+     * @param actualValues
+     * @return
+     */
+    private static FieldFunction getFieldFunction(String expression, List<Object> actualValues) {
+        FieldFunction function = new FieldFunction(expression);
+        function.setArgValues(actualValues);
+        return function;
+
+    }
+
+}

src/main/java/io/opensaber/views/FunctionEvaluator.java

@@ -7,7 +7,7 @@
 import org.apache.commons.jexl2.MapContext;
 
 
-public class FunctionEvaluator {
+public class FunctionEvaluator implements IEvaluator<Object>{
 
     private static final JexlEngine jexl = new JexlEngine();
     private JexlContext jexlContext = new MapContext();
@@ -34,6 +34,7 @@ private void prepare() {
         setContextArgs();
     }
 
+    @Override
     public Object evaluate() {
         prepare();
         Object result = jexlExpression.evaluate(jexlContext);

src/main/java/io/opensaber/views/IEvaluator.java

@@ -0,0 +1,10 @@
+package io.opensaber.views;
+
+public interface IEvaluator<T> {
+    /**
+     * evaluates to provide result 
+     * From a given expression, a provider class, a reference template of a sview template
+     * @return
+     */
+    public T evaluate();
+}

src/main/java/io/opensaber/views/ProviderEvaluator.java

@@ -0,0 +1,47 @@
+package io.opensaber.views;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ProviderEvaluator implements IEvaluator<Object> {
+
+    private static Logger logger = LoggerFactory.getLogger(ProviderEvaluator.class);
+
+    private FieldFunction function;
+
+    public ProviderEvaluator(FieldFunction function) {
+        this.function = function;
+    }
+
+    @Override
+    public Object evaluate() {
+        IViewFunctionProvider<Object> viewFuntionProvider = getInstance(function.getExpression());
+        Object result = viewFuntionProvider.doAction(function.getArgValues());
+        return result;
+    }
+
+    /**
+     * invokes instance for given providerName
+     * @param providerName    full qualified name of class
+     * @return
+     */
+    public IViewFunctionProvider<Object> getInstance(String providerName) {
+
+        IViewFunctionProvider<Object> viewFunctionProvider = null;
+        try {
+            if (providerName == null || providerName.isEmpty()) {
+                throw new IllegalArgumentException(
+                        "view function provider class {} cannot be instantiate with empty value");
+            }
+            Class<?> advisorClass = Class.forName(providerName);
+            viewFunctionProvider = (IViewFunctionProvider) advisorClass.newInstance();
+            logger.info("Invoked view function provider class with classname: " + providerName);
+
+        } catch (ClassNotFoundException | SecurityException | InstantiationException | IllegalAccessException
+                | IllegalArgumentException e) {
+            logger.error("view function provider class {} cannot be instantiate with exception:", providerName, e);
+        }
+        return viewFunctionProvider;
+    }
+
+}

src/main/java/io/opensaber/views/Transformer.java

@@ -32,21 +32,22 @@ public JsonNode transform(ViewTemplate viewTemplate, ObjectNode node) {
             if (functionStr != null) {
 
                 String fdName = field.getFunctioName();
-                String expression = viewTemplate.getExpression(fdName);
-
-                FieldFunction function = new FieldFunction(expression);
+                FunctionDefinition funcDef = viewTemplate.getFunctionDefinition(fdName);            
+
                 List<Object> actualValues = new ArrayList<>();
                 for (String oneArg : field.getArgNames()) {
                     // Cut off the $
                     actualValues.add(ValueType.getValue(nodeAttrs.get(oneArg.substring(1))));
                 }
-                function.setArgValues(actualValues);
-
-                FunctionEvaluator evaluator = new FunctionEvaluator(function);
-
+
+                IEvaluator<Object> evaluator = EvaluatorFactory.getInstance(funcDef, actualValues);
                 if (field.getDisplay()) {
-                    result.put(field.getTitle(), evaluator.evaluate().toString());
-
+                    Object evaluatedValue = evaluator.evaluate();
+                    if(evaluatedValue instanceof String){
+                        result.put(field.getTitle(), evaluatedValue.toString());
+                    } else {
+                        result.set(field.getTitle(), JsonNodeFactory.instance.pojoNode(evaluatedValue));
+                    }
                 }
             } else if (field.getDisplay()) {
                 result.set(field.getTitle(), nodeAttrs.get(field.getName()));
@@ -56,5 +57,6 @@ public JsonNode transform(ViewTemplate viewTemplate, ObjectNode node) {
         logger.debug("Node transformation result: " + result);
         return JsonNodeFactory.instance.objectNode().set(subjectType, result);
     }
+
 
 }

src/main/java/io/opensaber/views/ViewTemplate.java

@@ -38,25 +38,24 @@ public List<Field> getFields() {
     public void setFields(List<Field> fields) {
         this.fields = fields;
     }
+
     /**
-     * return the result for a given function name 
-     * Example: "arg1 + \" : \" + arg2"
-     * 
-     * @param name      function name (like concat)
-     * @return          result
+     * return a FunctionDefinition for a given function name 
+
+     * @param name    function name (like concat)
+     * @return
      */
-    public String getExpression(String name) {
-        String expression = "";
+    public FunctionDefinition getFunctionDefinition(String name) {
+        FunctionDefinition functionDef = null;
         for (FunctionDefinition fd : this.getFunctionDefinitions()) {
             if (fd.getName().compareTo(name) == 0) {
-                expression = fd.getResult();
-
+                functionDef = fd;
             }
         }
-        if (expression.isEmpty()) {
+        if (functionDef == null) {
             logger.error("No function definition specified for function - " + name);
             throw new IllegalArgumentException("No function definition specified for function - " + name);
         }
-        return expression;
+        return functionDef;
     }
 }

src/main/java/org/example/provider/SampleViewFunctionProvider.java

@@ -0,0 +1,31 @@
+package org.example.provider;
+
+import io.opensaber.views.IViewFunctionProvider;
+import java.util.List;
+/**
+ * This class is a sample implementation class of IViewFunctionProvider<T>
+ *
+ */
+public class SampleViewFunctionProvider implements IViewFunctionProvider<String> {
+
+    @Override
+    public String doAction(List<Object> values) {
+        // doing a simple concat for the values
+        return concat(values);
+    }
+
+    /**
+     * simple concat for the values as string and comma(',') as seperator
+     * 
+     * @param args
+     * @return
+     */
+    public String concat(List<Object> args) {
+        String res = "";
+        for (Object arg : args) {
+            res = res.toString().isEmpty() ? arg.toString() : (res + " : " + arg.toString());
+        }
+        return res;
+    }
+
+}

src/test/java/io/opensaber/views/TransformerTest.java

@@ -18,27 +18,17 @@ public class TransformerTest {
     private Transformer transformer = new Transformer();
 
     @Test
-    public void testTransformForPersonVT() throws JsonProcessingException, IOException{
-        String personJson = "{\"Person\": " +
-                "               {\"nationalIdentifier\":\"nid823\"," +
-                "                \"firstName\":\"Ram\"," +
-                "                \"lastName\":\"Moorthy\"," +
-                "                \"gender\":\"MALE\"," +
-                "                \"dob\":\"1990-12-10\"}}";
-        ObjectNode personNode = (ObjectNode) new ObjectMapper().readTree(personJson);
-        String viewTemplateJson = readFileContent("personVT1.json");
-        ViewTemplate viewTemplate = new ObjectMapper().readValue(viewTemplateJson, ViewTemplate.class);
+    public void testTransformForPersonFunction() throws JsonProcessingException, IOException{
 
-        JsonNode actualnode = transformer.transform(viewTemplate, personNode);  
+        ObjectNode personNode = getPerson();
+        ViewTemplate viewTemplate = getViewTemplatePerson("person_vt.json");
 
-        System.out.println("actualnode = "+actualnode);
-        JsonNode expectedNode = new ObjectMapper().readTree("{\"Person\":{\"NAME\":\"Ram\",\"lastName\":\"Moorthy\",\"Name in passport\":\"Moorthy, Ram\"}}");
-        System.out.println("expectedNode = "+expectedNode);
+        JsonNode actualnode = transformer.transform(viewTemplate, personNode);  
+        JsonNode expectedNode = new ObjectMapper().readTree("{\"Person\":{\"NAME\":\"Ram\",\"lastName\":\"Moorthy\",\"Name in passport\":\"Moorthy, Ram\",\"Name as in DL\":\"Ram : Moorthy\"}}");
 
         assertEquals(expectedNode, actualnode);
 
     }
-
 
     @Test
     public void testTransformForMathVT() throws JsonProcessingException, IOException{
@@ -47,14 +37,29 @@ public void testTransformForMathVT() throws JsonProcessingException, IOException
                 "                \"b\": 2 }}";
         ObjectNode node = (ObjectNode) new ObjectMapper().readTree(mathProblem);
 
-        String viewTemplateJson = readFileContent("mathVT1.json");
-        ViewTemplate viewTemplate = new ObjectMapper().readValue(viewTemplateJson, ViewTemplate.class);
-
+        ViewTemplate viewTemplate = getViewTemplatePerson("mathVT1.json");
         JsonNode actualnode = transformer.transform(viewTemplate, node); 
-        JsonNode expectedNode = new ObjectMapper().readTree("{\"Math\":{\"addend_A\":5,\"addend_B\":2,\"SUM\":\"7\"}}");        
+        JsonNode expectedNode = new ObjectMapper().readTree("{\"Math\":{\"addend_A\":5,\"addend_B\":2,\"SUM\":7}}");        
         assertEquals(expectedNode.toString(), actualnode.toString());
 
     }
+
+
+    private ViewTemplate getViewTemplatePerson(String personJsonFileName) throws JsonProcessingException, IOException{
+
+        String viewTemplateJson = readFileContent(personJsonFileName);
+        return new ObjectMapper().readValue(viewTemplateJson, ViewTemplate.class);
+    }
+
+    private ObjectNode getPerson() throws JsonProcessingException, IOException{
+        String personJson = "{\"Person\": " +
+                "               {\"nationalIdentifier\":\"nid823\"," +
+                "                \"firstName\":\"Ram\"," +
+                "                \"lastName\":\"Moorthy\"," +
+                "                \"gender\":\"MALE\"," +
+                "                \"dob\":\"1990-12-10\"}}";
+        return (ObjectNode) new ObjectMapper().readTree(personJson);
+    }
 
     private static String readFileContent(String fileName) {
         InputStream in;

src/test/java/io/opensaber/views/ViewTemplateTest.java

@@ -26,17 +26,17 @@ public void init() {
     @Test
     public void testGetExpression() {
 
-        String result = vt.getExpression("name");
+        FunctionDefinition fd = vt.getFunctionDefinition("name");
 
-        assertEquals(vt.getFunctionDefinitions().get(0).getResult(), result);
-        assertNotEquals("unexpected", result);
+        assertEquals(vt.getFunctionDefinitions().get(0).getResult(), fd.getResult());
+        assertNotEquals("unexpected", fd.getResult());
 
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void testGetExpressionException() {
 
-        vt.getExpression("invalid_name");
+        vt.getFunctionDefinition("invalid_name");
 
     }
 

src/test/resources/personVT1.json → src/test/resources/person_ref.json

@@ -18,7 +18,7 @@
     },
     {
         "title": "Name in passport",
-        "function": "#/functionDefinitions/concat($lastName, $firstName)",
+        "function": "#/functionDefinitions/customDefinedConcat($lastName, $firstName)",
         "$comment": "This is a virtual field not defined in the schema"
     },
     {
@@ -37,12 +37,12 @@
       },
       {
             "name" : "userDefinedConcat",
-            "provider": "user.opensaber.registry.utils.MySplConcatenator",
+            "provider": "io.opensaber.provider.SampleViewFunctionProvider",
             "$comment" : "Complex operations that cannot be expressed easily in an in-line function definition can be implemented as a class. "
       },
       {
             "name" : "customDefinedConcat",
-            "$ref": "AnotherViewTemplate.json#functionDefinitions/customDefinedConcat",
+            "result": "arg1 + \", \" + arg2",
             "$comment": "The functions defined in another template can be reused"
       }
   ]