dcaedt_be/src/main/java/org/onap/sdc/dcae/ves/EventListenerDefinition.java

   1 package org.onap.sdc.dcae.ves;
   2
   3 import com.google.gson.Gson;
   4 import org.apache.commons.lang.StringUtils;
   5
   6 import java.util.HashSet;
   7 import java.util.Map;
   8 import java.util.Set;
   9 import java.util.function.Predicate;
  10 import java.util.stream.Collectors;
  11
  12 public class EventListenerDefinition extends VesDataTypeDefinition {
  13
  14         public static final String EVENT_ROOT = "event";
  15         private String $schema;
  16         private Map<String, VesDataTypeDefinition> definitions;
  17
  18         public String get$schema() {
  19                 return $schema;
  20         }
  21
  22         public void set$schema(String $schema) {
  23                 this.$schema = $schema;
  24         }
  25
  26         public Map<String, VesDataTypeDefinition> getDefinitions() {
  27                 return definitions;
  28         }
  29
  30         public void setDefinitions(Map<String, VesDataTypeDefinition> definitions) {
  31                 this.definitions = definitions;
  32         }
  33
  34         // returns error message detailing unresolvable types - or null (success)
  35         public String resolveRefTypes() {
  36
  37                 Predicate<Map.Entry<String, VesDataTypeDefinition>> isFullyResolved = dt -> !dt.getValue().containsAnyReferenceItem();
  38                 Map<String, VesDataTypeDefinition> resolved = definitions.entrySet().stream()
  39                                 .filter(isFullyResolved)
  40                                 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
  41
  42                 int initialUnresolvedItems = -1;
  43                 int remainingUnresolvedItems = 0;
  44
  45                 while (resolved.size() != definitions.size() && initialUnresolvedItems != remainingUnresolvedItems) {
  46                         initialUnresolvedItems = definitions.size() - resolved.size();
  47                         definitions.entrySet().forEach(definition -> {
  48                                 if (!resolved.containsKey(definition.getKey()) && definition.getValue().isResolvable(resolved)) {
  49                                         definition.getValue().resolveAllReferences(resolved);
  50                                         resolved.put(definition.getKey(), definition.getValue());
  51                                 }
  52                         });
  53                         remainingUnresolvedItems = definitions.size() - resolved.size();
  54                 }
  55
  56                 if (resolved.size() != definitions.size()) {
  57                         definitions.keySet().removeAll(resolved.keySet());
  58                         return constructErrorMessage(definitions.keySet());
  59                 }
  60                 return resolveRootRefTypes();
  61
  62         }
  63
  64         private String constructErrorMessage(Set<String> unresolvable) {
  65                 return "the following definitions containing unresolvable references: " + new Gson().toJson(unresolvable);
  66         }
  67
  68         private String resolveRootRefTypes() {
  69                 Set<String> unresolvable = new HashSet<>();
  70                 getProperties().forEach((k, v) -> {
  71                         if (isResolvable(definitions))
  72                                 resolveAllReferences(definitions);
  73                         else
  74                                 unresolvable.add(k);
  75                 });
  76                 return unresolvable.isEmpty() ? null : constructErrorMessage(unresolvable);
  77
  78         }
  79
  80         @Override
  81         public String validate() {
  82                 String error = getProperties().containsKey(EVENT_ROOT) ? null : "schema not containing property: event";
  83                 if (StringUtils.isBlank(error))
  84                         error = super.validate();
  85                 if (StringUtils.isBlank(error))
  86                         error = validateDefinitions();
  87                 return error;
  88         }
  89
  90         private String validateDefinitions() {
  91                 String error = null;
  92                 for (VesDataTypeDefinition def : definitions.values()) {
  93                         if (StringUtils.isBlank(error))
  94                                 error = def.validate();
  95                         else
  96                                 break;
  97                 }
  98                 return error;
  99         }
 100
 101 }