Issue #000 feat: rename ISchema to ISchemaValidator

ontology-engine/graph-engine/src/main/java/org/sunbird/graph/engine/BaseManager.java

@@ -0,0 +1,47 @@
+package org.sunbird.graph.engine;
+
+import akka.actor.ActorRef;
+import org.sunbird.actor.core.BaseActor;
+import org.sunbird.common.JsonUtils;
+import org.sunbird.common.dto.Response;
+import org.sunbird.common.dto.ResponseParams;
+import org.sunbird.common.exception.ResponseCode;
+import org.sunbird.schema.ISchemaValidator;
+import org.sunbird.schema.SchemaValidatorFactory;
+import org.sunbird.schema.dto.ValidationResult;
+
+import java.util.Map;
+
+public abstract class BaseManager extends BaseActor {
+
+    /**
+     * This fetches the schema for given objectType and version and validates data against the schema.
+     *
+     * @param objectType
+     * @param version
+     * @param request
+     * @return ValidationResult
+     * @throws Exception
+     */
+
+    public ValidationResult validate(String objectType, String version, Map<String, Object> request) throws Exception {
+        ISchemaValidator schema = SchemaValidatorFactory.getInstance(objectType, version);
+        return schema.validate(JsonUtils.serialize(request));
+    }
+
+    public void ERROR(String errorCode, String errorMessage, ResponseCode code, String responseIdentifier, Object vo) {
+        Response response = new Response();
+        response.put(responseIdentifier, vo);
+        response.setParams(getErrorStatus(errorCode, errorMessage));
+        response.setResponseCode(code);
+        sender().tell(response, getSelf());
+    }
+
+    private ResponseParams getErrorStatus(String errorCode, String errorMessage) {
+        ResponseParams params = new ResponseParams();
+        params.setErr(errorCode);
+        params.setStatus(ResponseParams.StatusType.failed.name());
+        params.setErrmsg(errorMessage);
+        return params;
+    }
+}

ontology-engine/graph-engine/src/main/java/org/sunbird/graph/engine/actor/NodeManager.java

@@ -1,46 +1,39 @@
 package org.sunbird.graph.engine.actor;
 
-import org.sunbird.actor.core.BaseActor;
 import org.sunbird.actor.router.ActorConfig;
 import org.sunbird.common.JsonUtils;
 import org.sunbird.common.dto.Request;
 import org.sunbird.common.dto.Response;
-import org.sunbird.common.dto.ResponseParams;
 import org.sunbird.common.exception.ResponseCode;
-import org.sunbird.schema.ISchema;
-import org.sunbird.schema.SchemaFactory;
-import org.sunbird.schema.dto.Result;
+import org.sunbird.graph.engine.BaseManager;
+import org.sunbird.schema.dto.ValidationResult;
 
 import java.util.Map;
 
 @ActorConfig(tasks = {"createDataNode"})
-public class NodeManager extends BaseActor {
+public class NodeManager extends BaseManager {
 
     @Override
     public void onReceive(Request request) throws Throwable {
-        String action = request.getOperation();
-        switch (action) {
+        String operation = request.getOperation();
+        switch (operation) {
             case "createDataNode":
-                Result result = validate("content", "1.0", request.getRequest());
-                Response response = new Response("org.sunbird.content.create");
-                if (result.isValid()) {
-                    Map<String, Object> inputWithDefault = JsonUtils.deserialize(result.getData(), Map.class);
-
-                    response.getResult().put("content", inputWithDefault);
-                } else {
-                    response.setParams(new ResponseParams());
-                    response.setResponseCode(ResponseCode.CLIENT_ERROR);
-                    response.getResult().put("messages", result.getMessages());
-                }
-                OK(response, self());
+                createDataNode(request);
                 break;
             default:
-                ERROR(action);
+                ERROR(operation);
         }
     }
 
-    public Result validate(String objectType, String version, Map<String, Object> request) throws Exception {
-        ISchema schema = SchemaFactory.getInstance(objectType, version);
-        return schema.validate(JsonUtils.serialize(request));
+    private void createDataNode(Request request) throws Exception {
+        ValidationResult result = validate("content", "1.0", request.getRequest());
+        Response response = new Response("org.sunbird.content.create");
+        if (result.isValid()) {
+            Map<String, Object> inputWithDefault = JsonUtils.deserialize(result.getData(), Map.class);
+            response.getResult().put("content", inputWithDefault);
+            OK(response, self());
+        } else {
+            ERROR("NODE_VALIDATION_FAILED", "Validation errors.", ResponseCode.CLIENT_ERROR, "messages", result.getMessages());
+        }
     }
 }

platform-core/actor-core/src/main/java/org/sunbird/actor/core/BaseActor.java

@@ -35,7 +35,7 @@ protected void ERROR(String operation, Exception exception) throws Exception {
     sender().tell(getErrorResponse(exception), ActorRef.noSender());
   }
 
-    public void ERROR(String operation) throws Exception {
+    public void ERROR(String operation) {
         Response response = getErrorResponse(new ClientException(ResponseCode.CLIENT_ERROR.name(), "Invalid operation provided in request to process: " + operation));
         sender().tell(response, ActorRef.noSender());
     }

platform-core/schema-validator/src/main/java/org/sunbird/schema/ISchemaValidator.java

@@ -0,0 +1,15 @@
+package org.sunbird.schema;
+
+import org.sunbird.schema.dto.ValidationResult;
+
+import java.io.StringReader;
+import java.util.List;
+
+public interface ISchemaValidator {
+
+    ValidationResult validate(String data);
+
+    List<String> validate(StringReader input);
+
+    String withDefaultValues(String data);
+}

platform-core/schema-validator/src/main/java/org/sunbird/schema/SchemaFactory.java → platform-core/schema-validator/src/main/java/org/sunbird/schema/SchemaValidatorFactory.java

@@ -1,15 +1,15 @@
 package org.sunbird.schema;
 
-import org.sunbird.schema.impl.LocalSchema;
+import org.sunbird.schema.impl.LocalSchemaValidator;
 
 import java.util.HashMap;
 import java.util.Map;
 
-public class SchemaFactory {
+public class SchemaValidatorFactory {
 
-    private static Map<String, ISchema> schemaMap = new HashMap<String, ISchema>();
+    private static Map<String, ISchemaValidator> schemaMap = new HashMap<String, ISchemaValidator>();
 
-    public static ISchema getInstance(String name, String version) throws Exception {
+    public static ISchemaValidator getInstance(String name, String version) throws Exception {
         String key = getKey(name, version);
         if (schemaMap.containsKey(key)) {
             return schemaMap.get(key);
@@ -18,8 +18,8 @@ public static ISchema getInstance(String name, String version) throws Exception
         }
     }
 
-    private static ISchema initSchema(String name, String version) throws Exception {
-        ISchema schema = new LocalSchema(name, version);
+    private static ISchemaValidator initSchema(String name, String version) throws Exception {
+        ISchemaValidator schema = new LocalSchemaValidator(name, version);
         schemaMap.put(getKey(name, version), schema);
         return schema;
     }

platform-core/schema-validator/src/main/java/org/sunbird/schema/TestSchema.java

@@ -4,7 +4,7 @@ public class TestSchema {
 
     public static void main(String args[]) throws Exception {
         System.out.println("------------------------------------");
-        ISchema schema = SchemaFactory.getInstance("Content", "1.0");
+        ISchemaValidator schema = SchemaValidatorFactory.getInstance("Content", "1.0");
         System.out.println(schema.validate("{\"name\": \"Mahesh\", \"mimeType\": \"wor\"}"));
         System.out.println("------------------------------------");
         System.out.println(schema.validate("{\"name\": \"Mahesh\"}"));

platform-core/schema-validator/src/main/java/org/sunbird/schema/dto/Result.java → platform-core/schema-validator/src/main/java/org/sunbird/schema/dto/ValidationResult.java

@@ -4,13 +4,13 @@
 
 import java.util.List;
 
-public class Result {
+public class ValidationResult {
 
     private boolean valid = false;
     private List<String> messages;
     private String data;
 
-    public Result(String data, List<String> messages) {
+    public ValidationResult(String data, List<String> messages) {
         this.data = data;
         if (CollectionUtils.isEmpty(messages)) {
             this.valid = true;

platform-core/schema-validator/src/main/java/org/sunbird/schema/impl/LocalSchema.java → platform-core/schema-validator/src/main/java/org/sunbird/schema/impl/LocalSchemaValidator.java

@@ -8,16 +8,14 @@
 
 
 
-public class LocalSchema extends Schema {
+public class LocalSchemaValidator extends SchemaValidator {
 
     private static String basePath = "schema/";
 
-    public LocalSchema(String name, String version) throws Exception {
+    public LocalSchemaValidator(String name, String version) throws Exception {
         super(name, version);
         String fileName = name + "-" + version + ".json";
-
         URI uri = getClass().getClassLoader().getResource( basePath + fileName).toURI();
-        System.out.println("URI: " + uri);
         Path schemaPath = Paths.get(uri);
         this.schema = readSchema(schemaPath);
     }

platform-core/schema-validator/src/main/java/org/sunbird/schema/impl/Schema.java → platform-core/schema-validator/src/main/java/org/sunbird/schema/impl/SchemaValidator.java

@@ -2,32 +2,36 @@
 
 
 import org.leadpony.justify.api.*;
-import org.sunbird.schema.ISchema;
-import org.sunbird.schema.dto.Result;
+import org.sunbird.schema.ISchemaValidator;
+import org.sunbird.schema.dto.ValidationResult;
 
 import javax.json.JsonReader;
 import javax.json.JsonReaderFactory;
 import java.io.StringReader;
+import java.net.URI;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
 
-public abstract class Schema implements ISchema {
+public abstract class SchemaValidator implements ISchemaValidator {
 
     public static String name;
     public static String version;
     protected static final JsonValidationService service = JsonValidationService.newInstance();
     protected static JsonSchema schema;
     protected static JsonSchemaReaderFactory schemaReaderFactory;
 
-    public Schema(String name, String version) {
+    public SchemaValidator(String name, String version) {
         this.name = name;
         this.version = version;
         this.schemaReaderFactory = service.createSchemaReaderFactoryBuilder()
                 .withSchemaResolver(this::resolveSchema)
                 .build();
     }
 
+    public abstract JsonSchema resolveSchema(URI id);
+
+
     /**
      * Reads the JSON schema from the specified path.
      *
@@ -40,10 +44,10 @@ protected JsonSchema readSchema(Path path) {
         }
     }
 
-    public Result validate(String data) {
+    public ValidationResult validate(String data) {
         String dataWithDefaults = withDefaultValues(data);
         List<String> messages = validate(new StringReader(dataWithDefaults));
-        return new Result(dataWithDefaults, messages);
+        return new ValidationResult(dataWithDefaults, messages);
     }
 
     public List<String> validate(StringReader input) {

platform-core/schema-validator/src/main/resources/schema/content-1.0.json

@@ -39,21 +39,24 @@
                     "default": "content"
                 }
             }
+        },
+        {
+            "if": {
+                "properties": {
+                    "mimeType": {"const": "application/pdf"}
+                }
+            },
+            "then": {
+                "properties": {
+                    "contentEncoding": { "default": "gzip"}
+                }
+            },
+            "else" : {
+                "properties": {
+                    "contentEncoding": {"default": "identity"}
+                }
+            }
         }
-    ],
-    "if": {
-        "properties": {
-            "mimeType": {"const": "application/pdf"}
-        }
-    },
-    "then": {
-        "properties": {
-            "contentEncoding": { "default": "gzip"}
-        }
-    },
-    "else" : {
-        "properties": {
-            "contentEncoding": {"default": "identity"}
-        }
-    }
+
+    ]
 }