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