Creating domain structure for result objects

README.md

@@ -5,4 +5,4 @@
 This project contains all source files of the implementation, created for the master thesis.
 
 - [Backend Project](dmnverifierapi)
-- Frontend Project (TODO, create and add link)
+- [Frontend Project](dmnverifierfrontend)

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/api/test/GreetingResource.java

@@ -20,7 +20,8 @@ public class GreetingResource {
 
   private static Logger LOGGER = LoggerFactory.getLogger("test");
 
-  @Inject WordnetServiceX wordnetServiceX;
+  @Inject
+  WordnetServiceX wordnetServiceX;
 
   @ConfigProperty(name = "hello")
   private String greet;
@@ -28,7 +29,7 @@ public class GreetingResource {
   @GET
   @Produces(MediaType.APPLICATION_JSON)
   public Response hello() {
-    return Response.accepted(new Person(new Name("jonas"))).build();
+    return Response.accepted(new Person(new Name(greet + " Jonas"))).build();
   }
 
   @GET
@@ -36,7 +37,6 @@ public class GreetingResource {
   @Consumes(MediaType.TEXT_PLAIN)
   @Path("/{word}")
   public Response hello(@PathParam("word") String word) {
-    LOGGER.info("xxxxxxxxxxxxxxx" + word);
     return Response.accepted(new Synonyms(wordnetServiceX.getNounsSynonyms(word))).build();
   }
 

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/api/test/TestApi.java

@@ -6,12 +6,14 @@ import javax.ws.rs.Path;
 import javax.ws.rs.Produces;
 import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.Response;
+import org.eclipse.microprofile.config.inject.ConfigProperty;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 @Path("/builder")
 public class TestApi {
 
+
   private static Logger LOGGER = LoggerFactory.getLogger(TestApi.class.getSimpleName());
 
   @GET

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/json/JsonConfiguration.java

@@ -17,7 +17,6 @@ public class JsonConfiguration implements ContextResolver<Jsonb> {
             .withFormatting(true)
             .withStrictIJSON(true)
             .withPropertyVisibilityStrategy(new PrivateVisibilityStrategy());
-    System.out.println("Init Json Config " + type.getSimpleName());
     return JsonbBuilder.newBuilder().withConfig(config).build();
   }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/UniqueIdGenerator.java

@@ -2,11 +2,12 @@ package de.unikoblenz.fgbks.base.utils;
 
 public class UniqueIdGenerator {
 
-  private static long id = 0;
+  private static volatile long id = 0;
 
-  private UniqueIdGenerator() {}
+  private UniqueIdGenerator() {
+  }
 
-  public static long getNextId() {
-    return ++id;
+  public static synchronized long getNextId() {
+    return id++;
   }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verfication/VerificationClassification.java

-package de.unikoblenz.fgbks.core.dmn.verfication;
-
-import java.io.Serializable;
-
-public enum VerificationClassification implements Serializable {
-  DECISION_LOGIC_LEVEL_VERIFICATION("Decision Logic Verification");
-
-  private String name;
-
-  public String getName() {
-    return name;
-  }
-
-  VerificationClassification(String name) {
-    this.name = name;
-  }
-}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verfication/VerificationGenerator.java

 package de.unikoblenz.fgbks.core.dmn.verfication;
 
+import de.unikoblenz.fgbks.core.dmn.verfication.result.VerifierResult;
 import de.unikoblenz.fgbks.core.dmn.verfication.result.VerifierResultSet;
-import de.unikoblenz.fgbks.core.dmn.verfication.verifier.SampleVerifier;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import org.eclipse.microprofile.config.Config;
+import org.eclipse.microprofile.config.ConfigProvider;
 
 public class VerificationGenerator {
 
+  public static final String CONF_VERIFIER_THREADS = "verifier.threads";
+
   public static VerifierResultSet generate() {
-    return VerifierResultSet.getBuilder()
-        .addVerifierResult(
-            VerificationType.IDENTICAL_BUSINESS_RULE_VERIFICATION.getNewInstance().verify())
-        .addVerifierResult(new SampleVerifier().verify())
-        .build();
+
+    Config config = ConfigProvider.getConfig();
+    Integer maxThreads = config
+        .getOptionalValue(CONF_VERIFIER_THREADS, Integer.class)
+        .orElse(1);
+
+    ExecutorService executor = Executors.newFixedThreadPool(maxThreads);
+
+    VerifierResultSet.Builder resultBuilder = VerifierResultSet.getBuilder();
+
+    List<Future<VerifierResult>> results = new ArrayList<>(VerificationType.values().length);
+    System.out.println("Starting calculation with " + maxThreads + " threads.");
+    for (VerificationType vType : VerificationType.values()) {
+      results.add(vType.createNewInstance().verify(executor));
+    }
+
+    results.forEach(r -> {
+      try {
+        resultBuilder.addVerifierResult(r.get());
+      } catch (InterruptedException e) {
+        e.printStackTrace();
+      } catch (ExecutionException e) {
+        e.printStackTrace();
+      }
+    });
+
+    return resultBuilder.build();
   }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verfication/VerificationType.java

 package de.unikoblenz.fgbks.core.dmn.verfication;
 
-import static de.unikoblenz.fgbks.core.dmn.verfication.VerificationClassification.DECISION_LOGIC_LEVEL_VERIFICATION;
+import static de.unikoblenz.fgbks.core.dmn.verfication.VerificationTypeClassification.DECISION_LOGIC_LEVEL_VERIFICATION;
 
 import de.unikoblenz.fgbks.core.dmn.verfication.verifier.AbstractVerifier;
 import de.unikoblenz.fgbks.core.dmn.verfication.verifier.SampleVerifier;
@@ -12,25 +12,29 @@ public enum VerificationType implements Serializable {
   IDENTICAL_BUSINESS_RULE_VERIFICATION(
       DECISION_LOGIC_LEVEL_VERIFICATION, "Identical Business Rules");
 
-  private VerificationClassification classification;
+  private VerificationTypeClassification classification;
   private String name;
-  private transient Class<AbstractVerifier> verifierClass;
+  private String description;
+  private Class<? extends AbstractVerifier> verifierClass;
 
   @JsonbProperty("classification")
-  public VerificationClassification getClassification() {
+  public VerificationTypeClassification getClassification() {
     return classification;
   }
 
-  @JsonbProperty("name")
   public String getName() {
     return name;
   }
 
-  public AbstractVerifier getNewInstance() {
+  public String getDescription() {
+    return description;
+  }
+
+  public AbstractVerifier createNewInstance() {
     return new SampleVerifier();
   }
 
-  VerificationType(VerificationClassification classification, String name) {
+  VerificationType(VerificationTypeClassification classification, String name) {
     this.classification = Validate.notNull(classification);
     this.name = Validate.notBlank(name);
   }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verfication/VerificationTypeClassification.java

+package de.unikoblenz.fgbks.core.dmn.verfication;
+
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public enum VerificationTypeClassification implements Serializable {
+  DECISION_LOGIC_LEVEL_VERIFICATION("Decision Logic Verification", "",
+      new HashSet<>(Arrays.asList(VerificationType.IDENTICAL_BUSINESS_RULE_VERIFICATION)));
+
+  private String name;
+  private String description;
+  private Set<VerificationType> verificationTypes;
+
+  public String getName() {
+    return name;
+  }
+
+  public String getDescription() {
+    return description;
+  }
+
+  public Set<VerificationType> getVerificationTypes() {
+    return new HashSet<>(verificationTypes);
+  }
+
+  VerificationTypeClassification(String name, String description,
+      Set<VerificationType> verificationTypes) {
+    this.name = name;
+    this.description = description;
+    this.verificationTypes = verificationTypes;
+  }
+}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verfication/result/AbstractResultObject.java

@@ -3,10 +3,16 @@ package de.unikoblenz.fgbks.core.dmn.verfication.result;
 import de.unikoblenz.fgbks.base.utils.UniqueIdGenerator;
 import java.io.Serializable;
 import java.util.Objects;
+import javax.json.bind.annotation.JsonbProperty;
 
 public class AbstractResultObject implements Serializable {
 
-  private transient long id = UniqueIdGenerator.getNextId();
+  private long id = UniqueIdGenerator.getNextId();
+
+  @JsonbProperty("id")
+  public long getId() {
+    return id;
+  }
 
   @Override
   public boolean equals(Object o) {

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verfication/result/VerificationResultEntry.java

@@ -9,8 +9,13 @@ import org.apache.commons.lang3.Validate;
 
 public class VerificationResultEntry extends AbstractResultObject {
 
+  public enum VerificationClassification {
+    INFO, WARNING, ERROR, FATAL_ERROR;
+  }
+
   private Set<VerificationResultEntryElement> verificationResultEntryElements;
   private String message;
+  private VerificationClassification verificationClassification;
 
   protected VerificationResultEntry() {
     this.verificationResultEntryElements = ConcurrentHashMap.newKeySet();
@@ -26,6 +31,11 @@ public class VerificationResultEntry extends AbstractResultObject {
     return new HashSet<>(verificationResultEntryElements);
   }
 
+  @JsonbProperty("verificationClassification")
+  public VerificationClassification getVerificationClassification() {
+    return verificationClassification;
+  }
+
   @JsonbProperty("message")
   public String getMessage() {
     return message;
@@ -53,10 +63,16 @@ public class VerificationResultEntry extends AbstractResultObject {
       return this;
     }
 
+    public Builder withClassification(VerificationClassification verificationClassification) {
+      value.verificationClassification = verificationClassification;
+      return this;
+    }
+
     @Override
     protected void validate() {
       super.validate();
       Validate.notNull(value.message);
+      Validate.notNull(value.verificationClassification);
       Validate.notEmpty(value.verificationResultEntryElements);
     }
   }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verfication/result/VerificationResultEntryElement.java

@@ -3,46 +3,73 @@ package de.unikoblenz.fgbks.core.dmn.verfication.result;
 import java.util.HashMap;
 import java.util.Map;
 import javax.json.bind.annotation.JsonbProperty;
+import org.apache.commons.lang3.Validate;
 
 // @JsonbTypeSerializer(VerificationResultEntryElementJsonSerializer.class)
 public class VerificationResultEntryElement extends AbstractResultObject {
 
-  private static final String ID = "id";
-  private static final String TABLE = "table";
-  private String name;
-  private final Map<String, Object> properties = new HashMap<>();
+  private static final String DECISION_ID = "decisionId";
+  private static final String DECISION_TABLE_ID = "decisionTableId";
+  private static final String INPUT_ID = "inputId";
+  private static final String INPUT_EXPRESSION_ID = "inputExpressionId";
+  private static final String OUTPUT_ID = "outputId";
+  private static final String RULE_ID = "ruleId";
+  private static final String INPUT_ENTRY_ID = "inputEntryId";
+  private static final String OUTPUT_ENTRY_ID = "outputEntryId";
+
+  private final Map<String, Object> properties;
 
   @JsonbProperty("properties")
   public Map<String, Object> getProperties() {
     return new HashMap<>(properties);
   }
 
-  public VerificationResultEntryElement(String name) {
-    this.name = name;
+  private VerificationResultEntryElement() {
+    properties = new HashMap<>();
   }
 
-  public String getName() {
-    return name;
+  public static VerificationResultEntryElement create() {
+    return new VerificationResultEntryElement();
   }
 
-  public void setName(String name) {
-    this.name = name;
+  public VerificationResultEntryElement withDecisionId(String decisionId) {
+    return withProperty(DECISION_ID, decisionId);
   }
 
-  public VerificationResultEntryElement setId(String table) {
-    return setProperty(TABLE, table);
+  public VerificationResultEntryElement withDecisionTableId(String decisionTableId) {
+    return withProperty(DECISION_TABLE_ID, decisionTableId);
   }
 
-  public VerificationResultEntryElement setTable(String table) {
-    return setProperty(ID, table);
+  public VerificationResultEntryElement withInputId(String inputId) {
+    return withProperty(INPUT_ID, inputId);
   }
 
-  public VerificationResultEntryElement setProperty(String key, String value) {
-    properties.put(key, value);
-    return this;
+  public VerificationResultEntryElement withInputExpressionId(String inputExpressionId) {
+    return withProperty(INPUT_EXPRESSION_ID, inputExpressionId);
   }
 
-  // TODO, add properties to link dmn elements:
-  // e.g. whole tables, one row / column, or a single cell
+  public VerificationResultEntryElement withOutputId(String outputId) {
+    return withProperty(OUTPUT_ID, outputId);
+  }
 
+  public VerificationResultEntryElement withRuleId(String ruleId) {
+    return withProperty(RULE_ID, ruleId);
+  }
+
+  public VerificationResultEntryElement withInputEntryId(String inputEntryId) {
+    return withProperty(INPUT_ENTRY_ID, inputEntryId);
+  }
+
+  public VerificationResultEntryElement withOutputEntryId(String outputEntryId) {
+    return withProperty(OUTPUT_ENTRY_ID, outputEntryId);
+  }
+
+  private VerificationResultEntryElement withProperty(String key, String value) {
+    // every properties can only be set once
+    Validate
+        .isTrue(!properties.containsKey(key), "Property %s with value %s in %s already set", key,
+            value, VerificationResultEntryElement.class.getSimpleName());
+    properties.put(key, value);
+    return this;
+  }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verfication/result/VerificationResultEntryElementJsonSerializer.java

-package de.unikoblenz.fgbks.core.dmn.verfication.result;
-
-import javax.json.bind.serializer.JsonbSerializer;
-import javax.json.bind.serializer.SerializationContext;
-import javax.json.stream.JsonGenerator;
-
-public class VerificationResultEntryElementJsonSerializer
-    implements JsonbSerializer<VerificationResultEntryElement> {
-
-  @Override
-  public void serialize(
-      VerificationResultEntryElement obj, JsonGenerator generator, SerializationContext ctx) {}
-}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verfication/result/VerificationResultEntryFactory.java

 package de.unikoblenz.fgbks.core.dmn.verfication.result;
 
+import de.unikoblenz.fgbks.core.dmn.verfication.result.VerificationResultEntry.VerificationClassification;
 import de.unikoblenz.fgbks.core.dmn.verfication.result.VerifierResult.Builder;
 import org.apache.commons.lang3.Validate;
 
@@ -30,12 +31,16 @@ public class VerificationResultEntryFactory {
     return this;
   }
 
-  public void addToEntry(String message) {
-    addToEntry(message, null);
+  public void addToEntry(VerificationClassification verificationClassification, String message) {
+    addToEntry(verificationClassification, message, null);
   }
 
-  public void addToEntry(String message, Object... args) {
-    verificationResultEntryBuilder.withMessage(String.format(message, args));
+  public void addToEntry(VerificationClassification verificationClassification, String message,
+      Object... args) {
+    Validate.notNull(verificationResultEntryBuilder,
+        "First call \"addElement\" in VerificationResultEntryFactory before calling \"addToEntry\"");
+    verificationResultEntryBuilder.withClassification(verificationClassification);
+    verificationResultEntryBuilder.withMessage(String.format(Validate.notNull(message), args));
     verifierResultBuilder.addVerificationResultEntry(verificationResultEntryBuilder.build());
     verificationResultEntryBuilder = null;
   }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verfication/result/VerifierResult.java

@@ -28,6 +28,16 @@ public class VerifierResult extends AbstractResultObject {
     return verificationType.getName();
   }
 
+  @JsonbProperty("type_description")
+  public String getVerificationTypeDescription(){
+    return verificationType.getDescription();
+  }
+
+  @JsonbProperty("type_classification")
+  public String getVerificationTypeClassification(){
+    return verificationType.getClassification().getName();
+  }
+
   @JsonbProperty("entries")
   public Set<VerificationResultEntry> getVerificationResultEntries() {
     return new HashSet<>(verificationResultEntries);

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verfication/verifier/AbstractVerifier.java

@@ -3,8 +3,14 @@ package de.unikoblenz.fgbks.core.dmn.verfication.verifier;
 import de.unikoblenz.fgbks.core.dmn.verfication.VerificationType;
 import de.unikoblenz.fgbks.core.dmn.verfication.result.VerificationResultEntryFactory;
 import de.unikoblenz.fgbks.core.dmn.verfication.result.VerifierResult;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
 
-public abstract class AbstractVerifier {
+public abstract class AbstractVerifier implements Verifier {
 
   protected VerificationType verificationType;
   private VerifierResult.Builder resultBuilder;
@@ -20,10 +26,31 @@ public abstract class AbstractVerifier {
     vref = VerificationResultEntryFactory.create(resultBuilder);
   }
 
+  public final Future<VerifierResult> verify(ExecutorService executor) {
+    return executor.submit((Callable<VerifierResult>) this::verify);
+  }
+
   public final VerifierResult verify() {
     doVerification();
     return resultBuilder.build();
   }
 
   protected abstract void doVerification();
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    AbstractVerifier that = (AbstractVerifier) o;
+    return verificationType == that.verificationType;
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(verificationType);
+  }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verfication/verifier/SampleVerifier.java

 package de.unikoblenz.fgbks.core.dmn.verfication.verifier;
 
 import static de.unikoblenz.fgbks.core.dmn.verfication.VerificationType.IDENTICAL_BUSINESS_RULE_VERIFICATION;
+import static de.unikoblenz.fgbks.core.dmn.verfication.result.VerificationResultEntry.VerificationClassification.*;
 
 import de.unikoblenz.fgbks.core.dmn.verfication.result.VerificationResultEntryElement;
 
@@ -12,20 +13,20 @@ public class SampleVerifier extends AbstractVerifier {
 
   @Override
   protected void doVerification() {
-    vref.addElement(new VerificationResultEntryElement("test 1").setId("21313").setTable("asad"))
-        .addElement(new VerificationResultEntryElement("test 4"))
-        .addElement(new VerificationResultEntryElement("test 3"))
-        .addElement(new VerificationResultEntryElement("test 2"))
-        .addToEntry("Test");
-    vref.addElement(new VerificationResultEntryElement("test 1"))
-        .addElement(new VerificationResultEntryElement("test 4"))
-        .addElement(new VerificationResultEntryElement("test 3"))
-        .addElement(new VerificationResultEntryElement("test 2"))
-        .addToEntry("Tes  324423t");
-    vref.addElement(new VerificationResultEntryElement("A 1"))
-        .addElement(new VerificationResultEntryElement("tBest 4"))
-        .addElement(new VerificationResultEntryElement("teCst 3"))
-        .addElement(new VerificationResultEntryElement("tesDt 2"))
-        .addToEntry("AAA 4353 43 est");
+    vref.addElement(VerificationResultEntryElement.create()
+        .withDecisionId("hello workd")
+        .withInputEntryId("adsas")
+        .withRuleId("asdads"));
+    vref.addElement(VerificationResultEntryElement.create()
+        .withDecisionId("hello workd")
+        .withInputEntryId("adsas")
+        .withRuleId("asdads"));
+    vref.addToEntry(ERROR, "Asd");
+    try {
+      Thread.sleep(1500);
+    } catch (InterruptedException e) {
+      e.printStackTrace();
+    }
+
   }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verfication/verifier/Verifier.java

+package de.unikoblenz.fgbks.core.dmn.verfication.verifier;
+
+import de.unikoblenz.fgbks.core.dmn.verfication.result.VerifierResult;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+
+public interface Verifier {
+
+  Future<VerifierResult> verify(ExecutorService executor);
+}

dmnverifierapi/src/main/resources/application.properties

@@ -2,8 +2,12 @@
 %dev.hello=hello my
 hello=hello world
 
+# Quarkus cors settings
 quarkus.http.cors=true
 quarkus.http.cors.origins=http://localhost:8081
 quarkus.http.cors.headers=accept, authorization, content-type, x-requested-with
 quarkus.http.cors.methods=GET, OPTIONS
 
+# Amount of threads for calculating the verifications
+verifier.threads=8
+%dev.verifier.threads=4