Init rest ws - tests and examples with quarkus and wordnet / react

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

+package de.unikoblenz.fgbks.api.test;
+
+import de.unikoblenz.fgbks.base.wordnet.WordnetService;
+import de.unikoblenz.fgbks.base.wordnet.WordnetServiceFunctions;
+import java.util.Set;
+import javax.enterprise.context.ApplicationScoped;
+
+@ApplicationScoped
+public class WordnetServiceX implements WordnetServiceFunctions {
+
+  private WordnetService wordnetService = WordnetService.getInstance();
+
+  @Override
+  public boolean areNounsSynonyms(String noun1, String noun2) {
+    return wordnetService.areNounsSynonyms(noun1, noun2);
+  }
+
+  @Override
+  public Set<String> getNounsSynonyms(String noun) {
+    return wordnetService.getNounsSynonyms(noun);
+  }
+}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/wordnet/WordnetService.java

+package de.unikoblenz.fgbks.base.wordnet;
+
+import edu.mit.jwi.Dictionary;
+import edu.mit.jwi.IDictionary;
+import edu.mit.jwi.item.IIndexWord;
+import edu.mit.jwi.item.ISynset;
+import edu.mit.jwi.item.IWord;
+import edu.mit.jwi.item.IWordID;
+import edu.mit.jwi.item.POS;
+import java.io.File;
+import java.net.URL;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * WordnetService provides some functions from wordnet <br>
+ * First, get the instance with getInstance() (singleton) and than use the provided functions.
+ */
+public final class WordnetService implements WordnetServiceFunctions {
+
+  private static final String PATH_WORDNET = "dict/";
+  // Singleton pattern
+  private static WordnetService instance;
+
+  private IDictionary dictionary;
+
+  private WordnetService() {
+    setupDictionary();
+  }
+
+  /**
+   * Get the singleton instance of the wordnet service.
+   *
+   * @param refresh true for a new initialisation of wordnet
+   * @return the wordnet service instance
+   */
+  public static WordnetService getInstance(boolean refresh) {
+    if (instance == null) {
+      instance = new WordnetService();
+    } else if (refresh) {
+      instance.setupDictionary();
+    }
+    return instance;
+  }
+
+  /**
+   * Get the singleton instance of the wordnet service.
+   *
+   * @return the wordnet service instance
+   */
+  public static WordnetService getInstance() {
+    return getInstance(false);
+  }
+
+  private void setupDictionary() {
+    if (dictionary != null) {
+      dictionary.close();
+    }
+    dictionary = null;
+    try {
+      String totalPath =
+          new File(getClass().getClassLoader().getResource(PATH_WORDNET).getFile())
+              .getAbsolutePath();
+      dictionary = new Dictionary(new URL("file", null, totalPath));
+      dictionary.open();
+    } catch (Exception e) {
+      dictionary = null;
+    }
+  }
+
+  /**
+   * Return true, if both nouns are in one synset. <br>
+   * "examination" & "exam" = true <br>
+   * "bill" & "invoice" = true<br>
+   *
+   * @return true, if both nouns are synonyms
+   */
+  @Override
+  public boolean areNounsSynonyms(String noun1, String noun2) {
+    if (dictionary == null) {
+      return false;
+    }
+    noun1 = noun1.toLowerCase().replace(" ", "_");
+    noun2 = noun2.toLowerCase().replace(" ", "_");
+    if (noun1.equals(noun2)) {
+      return false;
+    }
+    return getNounsSynonyms(noun1).contains(noun2);
+  }
+
+  @Override
+  public Set<String> getNounsSynonyms(String noun) {
+    if (dictionary == null) {
+      return Collections.emptySet();
+    }
+    noun = noun.toLowerCase().replace(" ", "_");
+    IIndexWord idxWord = null;
+    try {
+      idxWord = dictionary.getIndexWord(noun, POS.NOUN);
+    } catch (Exception e) {
+      // nothing
+    }
+    if (idxWord == null) {
+      return Collections.emptySet();
+    }
+    List<IWordID> wordIDs = idxWord.getWordIDs();
+    Set<String> returnSet = new HashSet<>();
+    for (IWordID wordID : wordIDs) {
+      IWord word = dictionary.getWord(wordID);
+      ISynset synset = word.getSynset();
+
+      // iterate over words associated with the synset
+      for (IWord w : synset.getWords()) {
+        returnSet.add(w.getLemma());
+      }
+    }
+    return returnSet;
+  }
+
+  /** Close the wordnet dictionary. */
+  public void close() {
+    if (dictionary != null && dictionary.isOpen()) {
+      dictionary.close();
+    }
+  }
+}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/wordnet/WordnetServiceFunctions.java

+package de.unikoblenz.fgbks.base.wordnet;
+
+import java.util.Set;
+
+public interface WordnetServiceFunctions {
+  /**
+   * Return true, if both nouns are in one synset. <br>
+   * "examination" & "exam" = true <br>
+   * "bill" & "invoice" = true<br>
+   *
+   * @return true, if both nouns are synonyms
+   */
+  boolean areNounsSynonyms(String noun1, String noun2);
+
+  Set<String> getNounsSynonyms(String noun);
+}

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 de.unikoblenz.fgbks.core.dmn.verfication.verifier.AbstractVerifier;
+import de.unikoblenz.fgbks.core.dmn.verfication.verifier.SampleVerifier;
+import java.io.Serializable;
+import javax.json.bind.annotation.JsonbProperty;
+import org.apache.commons.lang3.Validate;
+
+public enum VerificationType implements Serializable {
+  IDENTICAL_BUSINESS_RULE_VERIFICATION(
+      DECISION_LOGIC_LEVEL_VERIFICATION, "Identical Business Rules");
+
+  private VerificationClassification classification;
+  private String name;
+  private transient Class<AbstractVerifier> verifierClass;
+
+  @JsonbProperty("classification")
+  public VerificationClassification getClassification() {
+    return classification;
+  }
+
+  @JsonbProperty("name")
+  public String getName() {
+    return name;
+  }
+
+  public AbstractVerifier getNewInstance() {
+    return new SampleVerifier();
+  }
+
+  VerificationType(VerificationClassification classification, String name) {
+    this.classification = Validate.notNull(classification);
+    this.name = Validate.notBlank(name);
+  }
+}

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

+package de.unikoblenz.fgbks.core.dmn.verfication.result;
+
+import de.unikoblenz.fgbks.base.builder.DefaultBuilder;
+import de.unikoblenz.fgbks.core.dmn.verfication.VerificationType;
+import de.unikoblenz.fgbks.core.dmn.verfication.verifier.AbstractVerifier;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import javax.json.bind.annotation.JsonbProperty;
+import org.apache.commons.lang3.Validate;
+
+public class VerifierResult extends AbstractResultObject {
+
+  private VerificationType verificationType;
+  private Set<VerificationResultEntry> verificationResultEntries;
+
+  public VerifierResult() {
+    this.verificationResultEntries = ConcurrentHashMap.newKeySet();
+  }
+
+  @JsonbProperty("type")
+  public VerificationType getVerificationType() {
+    return verificationType;
+  }
+
+  @JsonbProperty("type_name")
+  public String getVerificationTypeName() {
+    return verificationType.getName();
+  }
+
+  @JsonbProperty("entries")
+  public Set<VerificationResultEntry> getVerificationResultEntries() {
+    return new HashSet<>(verificationResultEntries);
+  }
+
+  @JsonbProperty("size")
+  public int getAmountOfEntries() {
+    return verificationResultEntries.size();
+  }
+
+  public static Builder getBuilder() {
+    return new VerifierResult().new Builder();
+  }
+
+  public class Builder extends DefaultBuilder<VerifierResult> {
+
+    public Builder withVerificationType(VerificationType verificationType) {
+      value.verificationType = Validate.notNull(verificationType);
+      return this;
+    }
+
+    public Builder addVerificationResultEntry(VerificationResultEntry verificationResultEntry) {
+      value.verificationResultEntries.add(Validate.notNull(verificationResultEntry));
+      return this;
+    }
+
+    public Builder fromVerifier(AbstractVerifier verifier) {
+      return withVerificationType(Validate.notNull(verifier).getVerificationType());
+    }
+
+    @Override
+    protected void validate() {
+      super.validate();
+      Validate.notNull(value.verificationType);
+    }
+  }
+}

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

+package de.unikoblenz.fgbks.core.dmn.verfication.result;
+
+import de.unikoblenz.fgbks.base.builder.DefaultBuilder;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import javax.json.bind.annotation.JsonbProperty;
+import org.apache.commons.lang3.Validate;
+
+public class VerifierResultSet extends AbstractResultObject {
+
+  private Set<VerifierResult> verifierResults;
+
+  protected VerifierResultSet() {
+    this.verifierResults = ConcurrentHashMap.newKeySet();
+  }
+
+  @JsonbProperty("verifier")
+  public Set<VerifierResult> getVerifierResults() {
+    return new HashSet<>(verifierResults);
+  }
+
+  @JsonbProperty("size")
+  public int getAmountOfVerifier() {
+    return verifierResults.size();
+  }
+
+  private void addVerifierResult(VerifierResult verifierResult) {
+    verifierResults.add(verifierResult);
+  }
+
+  public static Builder getBuilder() {
+    return new VerifierResultSet().new Builder();
+  }
+
+  public class Builder extends DefaultBuilder<VerifierResultSet> {
+
+    public Builder addVerifierResult(VerifierResult verifierResult) {
+      value.addVerifierResult(Validate.notNull(verifierResult));
+      return this;
+    }
+  }
+}