models-base/src/main/java/org/onap/policy/models/base/PfConceptContainer.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019 Nordix Foundation.
   4  * ================================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.models.base;
  22
  23 import java.lang.reflect.ParameterizedType;
  24 import java.util.ArrayList;
  25 import java.util.LinkedHashMap;
  26 import java.util.List;
  27 import java.util.Map;
  28 import java.util.Map.Entry;
  29 import java.util.NavigableMap;
  30 import java.util.Set;
  31 import java.util.TreeMap;
  32
  33 import javax.persistence.CascadeType;
  34 import javax.persistence.EmbeddedId;
  35 import javax.persistence.Entity;
  36 import javax.persistence.FetchType;
  37 import javax.persistence.ManyToMany;
  38 import javax.persistence.Table;
  39 import javax.ws.rs.core.Response;
  40
  41 import lombok.Data;
  42 import lombok.EqualsAndHashCode;
  43 import lombok.NonNull;
  44
  45 import org.onap.policy.common.utils.validation.Assertions;
  46 import org.onap.policy.models.base.PfValidationResult.ValidationResult;
  47
  48 // @formatter:off
  49 /**
  50  * This class is a concept container and holds a map of concepts. The {@link PfConceptContainer} class implements the
  51  * helper methods of the {@link PfConceptGetter} interface to allow {@link PfConceptContainer} instances to be retrieved
  52  * by calling methods directly on this class without referencing the contained map.
  53  *
  54  * <p>Validation checks that a container key is not null. An error is issued if no concepts are defined in a container.
  55  * Each concept entry is checked to ensure that its key and value are not null and that the key matches the key in the
  56  * map value. Each concept entry is then validated individually.
  57  *
  58  * @param C the concept being contained
  59  */
  60 //@formatter:on
  61 @Entity
  62 @Table(name = "PfConceptContainer")
  63 @Data
  64 @EqualsAndHashCode(callSuper = false)
  65
  66 public class PfConceptContainer<C extends PfConcept, A extends PfNameVersion> extends PfConcept
  67         implements PfConceptGetter<C>, PfAuthorative<List<Map<String, A>>> {
  68     private static final long serialVersionUID = -324211738823208318L;
  69
  70     @EmbeddedId
  71     private PfConceptKey key;
  72
  73     @ManyToMany(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
  74     private Map<PfConceptKey, C> conceptMap;
  75
  76     /**
  77      * The Default Constructor creates a {@link PfConceptContainer} object with a null artifact key and creates an empty
  78      * concept map.
  79      */
  80     public PfConceptContainer() {
  81         this(new PfConceptKey());
  82     }
  83
  84     /**
  85      * The Key Constructor creates a {@link PfConceptContainer} object with the given artifact key and creates an empty
  86      * concept map.
  87      *
  88      * @param key the concept key
  89      */
  90     public PfConceptContainer(@NonNull final PfConceptKey key) {
  91         this(key, new TreeMap<PfConceptKey, C>());
  92     }
  93
  94     /**
  95      * This Constructor creates an concept container with all of its fields defined.
  96      *
  97      * @param key the concept container key
  98      * @param conceptMap the concepts to be stored in the concept container
  99      */
 100     public PfConceptContainer(@NonNull final PfConceptKey key, @NonNull final Map<PfConceptKey, C> conceptMap) {
 101         super();
 102
 103         this.key = key;
 104         this.conceptMap = new TreeMap<>(conceptMap);
 105     }
 106
 107     /**
 108      * Copy constructor.
 109      *
 110      * @param copyConcept the concept to copy from
 111      */
 112     public PfConceptContainer(@NonNull final PfConceptContainer<C, A> copyConcept) {
 113         super(copyConcept);
 114     }
 115
 116     @Override
 117     public List<PfKey> getKeys() {
 118         final List<PfKey> keyList = key.getKeys();
 119
 120         for (final C concept : conceptMap.values()) {
 121             keyList.addAll(concept.getKeys());
 122         }
 123
 124         return keyList;
 125     }
 126
 127     @Override
 128     public List<Map<String, A>> toAuthorative() {
 129         Map<String, A> toscaPolicyMap = new LinkedHashMap<>();
 130
 131         for (Entry<PfConceptKey, C> conceptEntry : getConceptMap().entrySet()) {
 132             @SuppressWarnings("unchecked")
 133             PfAuthorative<A> authoritiveImpl = (PfAuthorative<A>) conceptEntry.getValue();
 134             toscaPolicyMap.put(conceptEntry.getKey().getName(), authoritiveImpl.toAuthorative());
 135         }
 136
 137         List<Map<String, A>> toscaPolicyMapList = new ArrayList<>();
 138         toscaPolicyMapList.add(toscaPolicyMap);
 139
 140         return toscaPolicyMapList;
 141     }
 142
 143     @Override
 144     public void fromAuthorative(List<Map<String, A>> authorativeList) {
 145         // Clear any existing map entries
 146         conceptMap.clear();
 147
 148         // Concepts are in lists of maps
 149         for (Map<String, A> incomingConceptMap : authorativeList) {
 150             // Add the map entries one by one
 151             for (Entry<String, A> incomingConceptEntry : incomingConceptMap.entrySet()) {
 152                 C jpaConcept = getConceptNewInstance();
 153
 154                 // This cast allows us to call the fromAuthorative method
 155                 @SuppressWarnings("unchecked")
 156                 PfAuthorative<A> authoritiveImpl = (PfAuthorative<A>) jpaConcept;
 157
 158                 if (incomingConceptEntry.getValue().getName() == null) {
 159                     incomingConceptEntry.getValue().setName(incomingConceptEntry.getKey());
 160                 }
 161
 162                 // Set the key name and the rest of the values on the concept
 163                 authoritiveImpl.fromAuthorative(incomingConceptEntry.getValue());
 164
 165                 // This cast gets the key of the concept
 166                 PfConceptKey conceptKey = (PfConceptKey) jpaConcept.getKey();
 167
 168                 // Set the concept key of the concept
 169                 conceptKey.setName(incomingConceptEntry.getValue().getName());
 170
 171                 if (incomingConceptEntry.getValue().getVersion() != null) {
 172                     conceptKey.setVersion(incomingConceptEntry.getValue().getVersion());
 173                 }
 174                 else {
 175                     conceptKey.setVersion(PfKey.NULL_KEY_VERSION);
 176                 }
 177
 178                 // After all that, save the map entry
 179                 conceptMap.put(conceptKey, jpaConcept);
 180             }
 181         }
 182
 183         if (conceptMap.isEmpty()) {
 184             throw new PfModelRuntimeException(Response.Status.BAD_REQUEST,
 185                     "An incoming list of concepts must have at least one entry");
 186         }
 187     }
 188
 189     @Override
 190     public void clean() {
 191         key.clean();
 192         for (final Entry<PfConceptKey, C> conceptEntry : conceptMap.entrySet()) {
 193             conceptEntry.getKey().clean();
 194             conceptEntry.getValue().clean();
 195         }
 196     }
 197
 198     @Override
 199     public PfValidationResult validate(@NonNull final PfValidationResult resultIn) {
 200         PfValidationResult result = resultIn;
 201
 202         if (key.equals(PfConceptKey.getNullKey())) {
 203             result.addValidationMessage(
 204                     new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, "key is a null key"));
 205         }
 206
 207         result = key.validate(result);
 208
 209         if (conceptMap.isEmpty()) {
 210             result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
 211                     "conceptMap may not be empty"));
 212         } else {
 213             result = validateConceptMap(result);
 214         }
 215
 216         return result;
 217     }
 218
 219     /**
 220      * Validate the concept map of the container.
 221      *
 222      * @param resultIn the incoming validation results so far
 223      * @return the validation results with the results of this validation added
 224      */
 225     private PfValidationResult validateConceptMap(final PfValidationResult resultIn) {
 226         PfValidationResult result = resultIn;
 227
 228         for (final Entry<PfConceptKey, C> conceptEntry : conceptMap.entrySet()) {
 229             if (conceptEntry.getKey().equals(PfConceptKey.getNullKey())) {
 230                 result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
 231                         "key on concept entry " + conceptEntry.getKey() + " may not be the null key"));
 232             } else
 233                 if (conceptEntry.getValue() == null) {
 234                     result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
 235                             "value on concept entry " + conceptEntry.getKey() + " may not be null"));
 236                 } else
 237                     if (!conceptEntry.getKey().equals(conceptEntry.getValue().getKey())) {
 238                         result.addValidationMessage(new PfValidationMessage(key, this.getClass(),
 239                                 ValidationResult.INVALID, "key on concept entry key " + conceptEntry.getKey()
 240                                         + " does not equal concept value key " + conceptEntry.getValue().getKey()));
 241                         result = conceptEntry.getValue().validate(result);
 242                     } else {
 243                         result = conceptEntry.getValue().validate(result);
 244                     }
 245         }
 246         return result;
 247     }
 248
 249     @Override
 250     public int compareTo(final PfConcept otherConcept) {
 251         if (otherConcept == null) {
 252             return -1;
 253         }
 254         if (this == otherConcept) {
 255             return 0;
 256         }
 257         if (getClass() != otherConcept.getClass()) {
 258             return this.hashCode() - otherConcept.hashCode();
 259         }
 260
 261         @SuppressWarnings("unchecked")
 262         final PfConceptContainer<C, A> other = (PfConceptContainer<C, A>) otherConcept;
 263         int retVal = key.compareTo(other.key);
 264         if (retVal != 0) {
 265             return retVal;
 266         }
 267
 268         if (!conceptMap.equals(other.conceptMap)) {
 269             return (conceptMap.hashCode() - other.conceptMap.hashCode());
 270         }
 271
 272         return 0;
 273     }
 274
 275     @Override
 276     public PfConcept copyTo(@NonNull final PfConcept target) {
 277         Assertions.instanceOf(target, PfConceptContainer.class);
 278
 279         @SuppressWarnings("unchecked")
 280         final PfConceptContainer<C, A> copy = (PfConceptContainer<C, A>) target;
 281         copy.setKey(new PfConceptKey(key));
 282         final Map<PfConceptKey, C> newConceptMap = new TreeMap<>();
 283         for (final Entry<PfConceptKey, C> conceptMapEntry : conceptMap.entrySet()) {
 284             C newC = getConceptNewInstance();
 285             conceptMapEntry.getValue().copyTo(newC);
 286             newConceptMap.put(new PfConceptKey(conceptMapEntry.getKey()), newC);
 287         }
 288         copy.setConceptMap(newConceptMap);
 289
 290         return copy;
 291     }
 292
 293     @Override
 294     public C get(final PfConceptKey conceptKey) {
 295         return new PfConceptGetterImpl<>((NavigableMap<PfConceptKey, C>) conceptMap).get(conceptKey);
 296     }
 297
 298     @Override
 299     public C get(final String conceptKeyName) {
 300         return new PfConceptGetterImpl<>((NavigableMap<PfConceptKey, C>) conceptMap).get(conceptKeyName);
 301     }
 302
 303     @Override
 304     public C get(final String conceptKeyName, final String conceptKeyVersion) {
 305         return new PfConceptGetterImpl<>((NavigableMap<PfConceptKey, C>) conceptMap).get(conceptKeyName,
 306                 conceptKeyVersion);
 307     }
 308
 309     @Override
 310     public Set<C> getAll(final String conceptKeyName) {
 311         return new PfConceptGetterImpl<>((NavigableMap<PfConceptKey, C>) conceptMap).getAll(conceptKeyName);
 312     }
 313
 314     @Override
 315     public Set<C> getAll(final String conceptKeyName, final String conceptKeyVersion) {
 316         return new PfConceptGetterImpl<>((NavigableMap<PfConceptKey, C>) conceptMap).getAll(conceptKeyName,
 317                 conceptKeyVersion);
 318     }
 319
 320     /**
 321      * Get a new empty instance of a concept for this concept map.
 322      *
 323      * @return the new instance
 324      */
 325     @SuppressWarnings("unchecked")
 326     private C getConceptNewInstance() {
 327         try {
 328             String conceptClassName =
 329                     ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0].getTypeName();
 330             return (C) Class.forName(conceptClassName).newInstance();
 331         } catch (Exception ex) {
 332             throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR,
 333                     "failed to instantiate instance of container concept class", ex);
 334         }
 335     }
 336 }