First try for DMN Parser

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

 package de.unikoblenz.fgbks.api.test;
 
+import de.unikoblenz.fgbks.core.dmn.utils.DmnObjectContainer;
 import de.unikoblenz.fgbks.core.dmn.utils.DmnService;
 import de.unikoblenz.fgbks.core.dmn.verification.VerificationService;
 import javax.inject.Inject;
@@ -18,6 +19,8 @@ public class TestApi {
 
   private static Logger LOGGER = LoggerFactory.getLogger(TestApi.class.getSimpleName());
 
+  @Inject private DmnService dmnService;
+
   @Inject private VerificationService verificationService;
 
   @GET
@@ -31,8 +34,8 @@ public class TestApi {
   @Produces(MediaType.TEXT_PLAIN)
   @Consumes(MediaType.TEXT_XML)
   public String xx(String payload) {
-    DmnService dmnService = DmnService.getDmnServiceFromXml(payload);
-    dmnService.x();
+    DmnObjectContainer container = dmnService.getDmnServiceFromXml(payload);
+    container.x();
     return "yes";
   }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/builder/DefaultBuilder.java

@@ -2,6 +2,7 @@ package de.unikoblenz.fgbks.base.builder;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Modifier;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 
@@ -51,7 +52,8 @@ public class DefaultBuilder<E> extends AbstractBuilder<E, DefaultBuilder<E>> {
   @Override
   protected E newInstance() {
     Class<?> directSubclass = getClass();
-    while (directSubclass.getSuperclass() != DefaultBuilder.class) {
+    while (directSubclass.getSuperclass() != DefaultBuilder.class
+        && !Modifier.isAbstract(directSubclass.getSuperclass().getModifiers())) {
       directSubclass = directSubclass.getSuperclass();
     }
     Type genericSuperclass = directSubclass.getGenericSuperclass();

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/domain/ids/AbstractId.java

@@ -16,4 +16,9 @@ public abstract class AbstractId extends AbstractStringValueObject {
   protected Integer getMaxLength() {
     return 100;
   }
+
+  @Override
+  public String toString() {
+    return this.getClassName() + ": " + this.getValue();
+  }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/domain/ids/DefinitionId.java

+package de.unikoblenz.fgbks.core.dmn.domain.ids;
+
+public class DefinitionId extends AbstractId {
+
+  public DefinitionId(DefinitionId initialValue) {
+    this(initialValue.getValue());
+  }
+
+  public DefinitionId(String initialValue) {
+    super(initialValue);
+  }
+}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/domain/values/VDmnDecision.java

 package de.unikoblenz.fgbks.core.dmn.domain.values;
 
 import de.unikoblenz.fgbks.core.dmn.domain.ids.DecisionId;
-import java.util.List;
 
 public interface VDmnDecision extends VDmnElement {
 
+  VDmnDefinition getDmnDefinition();
+
   DecisionId getDecisionId();
 
-  List<VDmnDecisionTable> getDmnDecisionTables();
+  VDmnDecisionTable getDmnDecisionTable();
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/domain/values/VDmnDefinition.java

+package de.unikoblenz.fgbks.core.dmn.domain.values;
+
+import de.unikoblenz.fgbks.core.dmn.domain.ids.DefinitionId;
+import java.util.List;
+
+public interface VDmnDefinition extends VDmnElement {
+
+  DefinitionId getDefinitionId();
+
+  List<VDmnDecision> getDmnDecisions();
+}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/domain/values/impl/VDmnDecisionImpl.java

@@ -3,18 +3,20 @@ package de.unikoblenz.fgbks.core.dmn.domain.values.impl;
 import de.unikoblenz.fgbks.core.dmn.domain.ids.DecisionId;
 import de.unikoblenz.fgbks.core.dmn.domain.values.VDmnDecision;
 import de.unikoblenz.fgbks.core.dmn.domain.values.VDmnDecisionTable;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import de.unikoblenz.fgbks.core.dmn.domain.values.VDmnDefinition;
 import org.apache.commons.lang3.Validate;
 
 public class VDmnDecisionImpl implements VDmnDecision {
 
+  private VDmnDefinition dmnDefinition;
   private DecisionId decisionId;
-  private List<VDmnDecisionTable> dmnDecisionTables;
+  private VDmnDecisionTable dmnDecisionTable;
 
-  private VDmnDecisionImpl() {
-    dmnDecisionTables = new ArrayList<>();
+  private VDmnDecisionImpl() {}
+
+  @Override
+  public VDmnDefinition getDmnDefinition() {
+    return dmnDefinition;
   }
 
   @Override
@@ -23,8 +25,8 @@ public class VDmnDecisionImpl implements VDmnDecision {
   }
 
   @Override
-  public List<VDmnDecisionTable> getDmnDecisionTables() {
-    return Collections.unmodifiableList(dmnDecisionTables);
+  public VDmnDecisionTable getDmnDecisionTable() {
+    return dmnDecisionTable;
   }
 
   public static Builder getBuilder() {
@@ -33,19 +35,24 @@ public class VDmnDecisionImpl implements VDmnDecision {
 
   public class Builder extends DmnElementBuilder<VDmnDecisionImpl> {
 
+    public Builder withDmnDefinition(VDmnDefinition dmnDefinition) {
+      value.dmnDefinition = dmnDefinition;
+      return this;
+    }
+
     public Builder withDecisionId(DecisionId decisionId) {
       value.decisionId = decisionId;
       return this;
     }
 
-    public Builder addDmnDecisionTable(VDmnDecisionTable dmnDecisionTable) {
-      value.dmnDecisionTables.add(Validate.notNull(dmnDecisionTable));
+    public Builder withDmnDecisionTable(VDmnDecisionTable dmnDecisionTable) {
+      value.dmnDecisionTable = dmnDecisionTable;
       return this;
     }
 
-    public Builder addDmnDecisionTableFromBuilder(
+    public Builder withDmnDecisionTableFromBuilder(
         VDmnDecisionTableImpl.Builder dmnDecisionTableBuilder) {
-      addDmnDecisionTable(dmnDecisionTableBuilder.getUnbuildValue());
+      withDmnDecisionTable(dmnDecisionTableBuilder.getUnbuildValue());
       dmnDecisionTableBuilder.withDmnDecision(value);
       return this;
     }
@@ -53,7 +60,9 @@ public class VDmnDecisionImpl implements VDmnDecision {
     @Override
     protected void validate() {
       super.validate();
+      Validate.notNull(value.dmnDefinition);
       Validate.notNull(value.decisionId);
+      Validate.notNull(value.dmnDecisionTable);
     }
   }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/domain/values/impl/VDmnDefinitionImpl.java

+package de.unikoblenz.fgbks.core.dmn.domain.values.impl;
+
+import de.unikoblenz.fgbks.core.dmn.domain.ids.DefinitionId;
+import de.unikoblenz.fgbks.core.dmn.domain.values.VDmnDecision;
+import de.unikoblenz.fgbks.core.dmn.domain.values.VDmnDefinition;
+import java.util.ArrayList;
+import java.util.List;
+import org.apache.commons.lang3.Validate;
+
+public class VDmnDefinitionImpl implements VDmnDefinition {
+
+  private DefinitionId definitionId;
+  private List<VDmnDecision> dmnDecisions;
+
+  private VDmnDefinitionImpl() {
+    dmnDecisions = new ArrayList<>();
+  }
+
+  @Override
+  public DefinitionId getDefinitionId() {
+    return definitionId;
+  }
+
+  @Override
+  public List<VDmnDecision> getDmnDecisions() {
+    return dmnDecisions;
+  }
+
+  public static Builder getBuilder() {
+    return new VDmnDefinitionImpl().new Builder();
+  }
+
+  public class Builder extends DmnElementBuilder<VDmnDefinitionImpl> {
+
+    public Builder withDefinitionId(DefinitionId definitionId) {
+      value.definitionId = definitionId;
+      return this;
+    }
+
+    public Builder addDmnDecision(VDmnDecision dmnDecision) {
+      value.dmnDecisions.add(Validate.notNull(dmnDecision));
+      return this;
+    }
+
+    public Builder addDmnDecisionFromBuilder(VDmnDecisionImpl.Builder dmnDecisionBuilder) {
+      addDmnDecision(dmnDecisionBuilder.getUnbuildValue());
+      dmnDecisionBuilder.withDmnDefinition(value);
+      return this;
+    }
+
+    @Override
+    protected void validate() {
+      super.validate();
+      Validate.notNull(value.definitionId);
+    }
+  }
+}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/domain/values/parser/DmnModelInstanceWrapper.java

+package de.unikoblenz.fgbks.core.dmn.domain.values.parser;
+
+import de.unikoblenz.fgbks.core.dmn.domain.values.VDmnDefinition;
+import org.camunda.bpm.model.dmn.DmnModelInstance;
+
+public interface DmnModelInstanceWrapper {
+
+  VDmnDefinition getVDmnDefinition(DmnModelInstance dmnModelInstance);
+}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/domain/values/parser/SimpleParser.java

+package de.unikoblenz.fgbks.core.dmn.domain.values.parser;
+
+import de.unikoblenz.fgbks.core.dmn.domain.ids.DecisionId;
+import de.unikoblenz.fgbks.core.dmn.domain.ids.DefinitionId;
+import de.unikoblenz.fgbks.core.dmn.domain.values.VDmnDefinition;
+import de.unikoblenz.fgbks.core.dmn.domain.values.impl.VDmnDecisionImpl;
+import de.unikoblenz.fgbks.core.dmn.domain.values.impl.VDmnDefinitionImpl;
+import javax.inject.Singleton;
+import org.camunda.bpm.model.dmn.DmnModelInstance;
+import org.camunda.bpm.model.dmn.instance.Decision;
+
+@Singleton
+public class SimpleParser implements DmnModelInstanceWrapper {
+
+  @Override
+  public VDmnDefinition getVDmnDefinition(DmnModelInstance dmnModel) {
+    VDmnDefinitionImpl.Builder definitionBuilder =
+        VDmnDefinitionImpl.getBuilder()
+            .withDefinitionId(new DefinitionId(dmnModel.getDefinitions().getId()));
+    for (Decision x : dmnModel.getModelElementsByType(Decision.class)) {
+      VDmnDecisionImpl.Builder vDmnDecisionBuilder =
+          VDmnDecisionImpl.getBuilder().withDecisionId(new DecisionId(x.getId()));
+      definitionBuilder.addDmnDecisionFromBuilder(vDmnDecisionBuilder);
+
+      x.getId();
+    }
+    return definitionBuilder.build();
+  }
+}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/utils/DmnObjectContainer.java

+package de.unikoblenz.fgbks.core.dmn.utils;
+
+import de.unikoblenz.fgbks.core.dmn.domain.values.VDmnDefinition;
+import java.util.List;
+import org.camunda.bpm.dmn.engine.DmnDecision;
+import org.camunda.bpm.model.dmn.DmnModelInstance;
+import org.camunda.bpm.model.dmn.instance.Decision;
+
+public class DmnObjectContainer {
+
+  private final List<DmnDecision> dmnDecisions;
+  private final DmnModelInstance dmnModel;
+  private final VDmnDefinition vDmnDefinition;
+
+  public List<DmnDecision> getDmnDecisions() {
+    return dmnDecisions;
+  }
+
+  public DmnModelInstance getDmnModel() {
+    return dmnModel;
+  }
+
+  public VDmnDefinition getvDmnDefinition() {
+    return vDmnDefinition;
+  }
+
+  public DmnObjectContainer(
+      List<DmnDecision> dmnDecisions, DmnModelInstance dmnModel, VDmnDefinition vDmnDefinition) {
+    this.dmnDecisions = dmnDecisions;
+    this.dmnModel = dmnModel;
+    this.vDmnDefinition = vDmnDefinition;
+  }
+
+  // TODO: delete!
+  public void x() {
+    dmnModel.getModelElementsByType(Decision.class).stream()
+        .map(a -> a.getId())
+        .forEach(System.out::println);
+  }
+}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/utils/DmnService.java

 package de.unikoblenz.fgbks.core.dmn.utils;
 
+import de.unikoblenz.fgbks.core.dmn.domain.values.VDmnDefinition;
+import de.unikoblenz.fgbks.core.dmn.domain.values.parser.SimpleParser;
 import java.nio.charset.Charset;
 import java.util.List;
+import javax.inject.Inject;
+import javax.inject.Singleton;
 import org.apache.commons.io.IOUtils;
 import org.camunda.bpm.dmn.engine.DmnDecision;
 import org.camunda.bpm.dmn.engine.DmnEngineConfiguration;
 import org.camunda.bpm.model.dmn.DmnModelInstance;
 import org.camunda.bpm.model.dmn.impl.DmnParser;
-import org.camunda.bpm.model.dmn.instance.Decision;
 
+@Singleton
 public class DmnService {
 
-  private final List<DmnDecision> dmnDecisions;
-  private final DmnModelInstance dmnModel;
+  @Inject SimpleParser simpleDmnParser;
 
-  public static DmnService getDmnServiceFromXml(String dmnXmlString) {
+  public DmnObjectContainer getDmnServiceFromXml(String dmnXmlString) {
     List<DmnDecision> dmnDecisions =
         DmnEngineConfiguration.createDefaultDmnEngineConfiguration()
             .buildEngine()
@@ -23,17 +26,7 @@ public class DmnService {
         new DmnParser()
             .parseModelFromStream(IOUtils.toInputStream(dmnXmlString, Charset.defaultCharset()));
 
-    return new DmnService(dmnDecisions, dmnModel);
-  }
-
-  private DmnService(List<DmnDecision> dmnDecisionsDmnModelInstance, DmnModelInstance dmnModel) {
-    this.dmnModel = dmnModel;
-    this.dmnDecisions = dmnDecisionsDmnModelInstance;
-  }
-
-  public void x() {
-    dmnModel.getModelElementsByType(Decision.class).stream()
-        .map(a -> a.getId())
-        .forEach(System.out::println);
+    VDmnDefinition vDmnDefinition = simpleDmnParser.getVDmnDefinition(dmnModel);
+    return new DmnObjectContainer(dmnDecisions, dmnModel, vDmnDefinition);
   }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verification/VerificationService.java

 package de.unikoblenz.fgbks.core.dmn.verification;
 
+import de.unikoblenz.fgbks.core.dmn.domain.values.parser.SimpleParser;
 import de.unikoblenz.fgbks.core.dmn.verification.result.VerifierResult;
 import de.unikoblenz.fgbks.core.dmn.verification.result.VerifierResultSet;
 import de.unikoblenz.fgbks.core.dmn.verification.result.VerifierResultSet.Builder;
@@ -16,6 +17,7 @@ import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
+import javax.inject.Inject;
 import javax.inject.Singleton;
 import org.eclipse.microprofile.config.Config;
 import org.eclipse.microprofile.config.ConfigProvider;
@@ -33,6 +35,8 @@ public class VerificationService {
   private ExecutorService executor;
   private Set<Class<?>> verifierClasses;
 
+  @Inject private SimpleParser parser;
+
   protected VerificationService() {
     Config config = ConfigProvider.getConfig();
     int maxThreads =