model/context-model/src/main/java/org/onap/policy/apex/model/contextmodel/concepts/AxContextSchemas.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2016-2018 Ericsson. All rights reserved.
   4  *  Modifications Copyright (C) 2019 Nordix Foundation.
   5  * ================================================================================
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * SPDX-License-Identifier: Apache-2.0
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.apex.model.contextmodel.concepts;
  23
  24 import java.util.List;
  25 import java.util.Map;
  26 import java.util.Map.Entry;
  27 import java.util.NavigableMap;
  28 import java.util.Set;
  29 import java.util.TreeMap;
  30
  31 import javax.persistence.CascadeType;
  32 import javax.persistence.EmbeddedId;
  33 import javax.persistence.Entity;
  34 import javax.persistence.JoinColumn;
  35 import javax.persistence.JoinTable;
  36 import javax.persistence.ManyToMany;
  37 import javax.persistence.Table;
  38 import javax.xml.bind.Unmarshaller;
  39 import javax.xml.bind.annotation.XmlAccessType;
  40 import javax.xml.bind.annotation.XmlAccessorType;
  41 import javax.xml.bind.annotation.XmlElement;
  42 import javax.xml.bind.annotation.XmlType;
  43
  44 import org.onap.policy.apex.model.basicmodel.concepts.AxArtifactKey;
  45 import org.onap.policy.apex.model.basicmodel.concepts.AxConcept;
  46 import org.onap.policy.apex.model.basicmodel.concepts.AxConceptGetter;
  47 import org.onap.policy.apex.model.basicmodel.concepts.AxConceptGetterImpl;
  48 import org.onap.policy.apex.model.basicmodel.concepts.AxKey;
  49 import org.onap.policy.apex.model.basicmodel.concepts.AxValidationMessage;
  50 import org.onap.policy.apex.model.basicmodel.concepts.AxValidationResult;
  51 import org.onap.policy.apex.model.basicmodel.concepts.AxValidationResult.ValidationResult;
  52 import org.onap.policy.common.utils.validation.Assertions;
  53
  54 /**
  55  * This class is a context schema container and holds a map of the context schemas for an entire Apex model. All Apex
  56  * models that use context schemas must have an {@link AxContextSchemas} field. The {@link AxContextSchemas} class
  57  * implements the helper methods of the {@link AxConceptGetter} interface to allow {@link AxContextSchema} instances to
  58  * be retrieved by calling methods directly on this class without referencing the contained map.
  59  *
  60  * <p>Validation checks that the container key is not null. An error is issued if no context schemas are defined in the
  61  * container. Each context schema entry is checked to ensure that its key and value are not null and that the key
  62  * matches the key in the map value. Each context schema entry is then validated individually.
  63  */
  64 @Entity
  65 @Table(name = "AxContextSchemas")
  66
  67 @XmlAccessorType(XmlAccessType.FIELD)
  68 @XmlType(name = "AxContextSchemas", namespace = "http://www.onap.org/policy/apex-pdp", propOrder =
  69     { "key", "schemas" })
  70
  71 public class AxContextSchemas extends AxConcept implements AxConceptGetter<AxContextSchema> {
  72     private static final long serialVersionUID = -3203734282886453582L;
  73
  74     @EmbeddedId
  75     @XmlElement(name = "key", required = true)
  76     private AxArtifactKey key;
  77
  78     // @formatter:off
  79     @ManyToMany(cascade = CascadeType.ALL)
  80     @JoinTable(
  81             joinColumns = {@JoinColumn(name = "contextSchemasName", referencedColumnName = "name"),
  82                     @JoinColumn(name = "contextSchemasVersion", referencedColumnName = "version")},
  83             inverseJoinColumns = {@JoinColumn(name = "contextSchemaName", referencedColumnName = "name"),
  84                     @JoinColumn(name = "contextSchemaVersion", referencedColumnName = "version")})
  85     @XmlElement(name = "schemas", required = true)
  86     private Map<AxArtifactKey, AxContextSchema> schemas;
  87     // @formatter:on
  88
  89     /**
  90      * The Default Constructor creates a {@link AxContextSchemas} object with a null artifact key and creates an empty
  91      * context schemas map.
  92      */
  93     public AxContextSchemas() {
  94         this(new AxArtifactKey());
  95     }
  96
  97     /**
  98      * Copy constructor.
  99      *
 100      * @param copyConcept the concept to copy from
 101      */
 102     public AxContextSchemas(final AxContextSchemas copyConcept) {
 103         super(copyConcept);
 104     }
 105
 106     /**
 107      * The Key Constructor creates a {@link AxContextSchemas} object with the given artifact key and creates an empty
 108      * context schemas map.
 109      *
 110      * @param key the key of the context album container
 111      */
 112     public AxContextSchemas(final AxArtifactKey key) {
 113         this(key, new TreeMap<AxArtifactKey, AxContextSchema>());
 114     }
 115
 116     /**
 117      * This Constructor creates a {@link AxContextSchemas} object with all its fields defined.
 118      *
 119      * @param key the key of the context schema container
 120      * @param schemas a map of the schemas to insert in the context schema container
 121      */
 122     public AxContextSchemas(final AxArtifactKey key, final Map<AxArtifactKey, AxContextSchema> schemas) {
 123         super();
 124         Assertions.argumentNotNull(key, "key may not be null");
 125         Assertions.argumentNotNull(schemas, "schemas may not be null");
 126
 127         this.key = key;
 128         this.schemas = new TreeMap<>();
 129         this.schemas.putAll(schemas);
 130     }
 131
 132     /**
 133      * When a model is unmarshalled from disk or from the database, the context schema map is returned as a raw hash
 134      * map. This method is called by JAXB after unmarshaling and is used to convert the hash map to a
 135      * {@link NavigableMap} so that it will work with the {@link AxConceptGetter} interface.
 136      *
 137      * @param unmarshaller the unmarshaler that is unmarshaling the model
 138      * @param parent the parent object of this object in the unmarshaler
 139      */
 140     public void afterUnmarshal(final Unmarshaller unmarshaller, final Object parent) {
 141         // The map must be navigable to allow name and version searching, unmarshaling returns a
 142         // hash map
 143         final NavigableMap<AxArtifactKey, AxContextSchema> navigableContextSchemas = new TreeMap<>();
 144         navigableContextSchemas.putAll(schemas);
 145         schemas = navigableContextSchemas;
 146     }
 147
 148     /**
 149      * {@inheritDoc}.
 150      */
 151     @Override
 152     public AxArtifactKey getKey() {
 153         return key;
 154     }
 155
 156     /**
 157      * {@inheritDoc}.
 158      */
 159     @Override
 160     public List<AxKey> getKeys() {
 161         final List<AxKey> keyList = key.getKeys();
 162         keyList.addAll(schemas.keySet());
 163
 164         return keyList;
 165     }
 166
 167     /**
 168      * Sets the key of the context schema container.
 169      *
 170      * @param key the key of the container
 171      */
 172     public void setKey(final AxArtifactKey key) {
 173         Assertions.argumentNotNull(key, "key may not be null");
 174         this.key = key;
 175     }
 176
 177     /**
 178      * Gets the map of context schemas in this container.
 179      *
 180      * @return the map of schemas
 181      */
 182     public Map<AxArtifactKey, AxContextSchema> getSchemasMap() {
 183         return schemas;
 184     }
 185
 186     /**
 187      * Sets the map of context schemas in this container.
 188      *
 189      * @param schemasMap the map of schemas
 190      */
 191     public void setSchemasMap(final Map<AxArtifactKey, AxContextSchema> schemasMap) {
 192         Assertions.argumentNotNull(schemasMap, "schemasMap may not be null");
 193
 194         this.schemas = new TreeMap<>();
 195         this.schemas.putAll(schemasMap);
 196     }
 197
 198     /**
 199      * {@inheritDoc}.
 200      */
 201     @Override
 202     public AxValidationResult validate(final AxValidationResult resultIn) {
 203         AxValidationResult result = resultIn;
 204
 205         if (key.equals(AxArtifactKey.getNullKey())) {
 206             result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
 207                             "key is a null key"));
 208         }
 209
 210         result = key.validate(result);
 211
 212         if (schemas.size() == 0) {
 213             result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
 214                             "contextSchemas may not be empty"));
 215         } else {
 216             for (final Entry<AxArtifactKey, AxContextSchema> contextSchemaEntry : schemas.entrySet()) {
 217                 if (contextSchemaEntry.getKey().equals(AxArtifactKey.getNullKey())) {
 218                     result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
 219                                     "key on schemas entry " + contextSchemaEntry.getKey()
 220                                                     + " may not be the null key"));
 221                 } else if (contextSchemaEntry.getValue() == null) {
 222                     result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
 223                                     "value on schemas entry " + contextSchemaEntry.getKey() + " may not be null"));
 224                 } else {
 225                     if (!contextSchemaEntry.getKey().equals(contextSchemaEntry.getValue().getKey())) {
 226                         result.addValidationMessage(
 227                                         new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
 228                                                         "key on schemas entry " + contextSchemaEntry.getKey()
 229                                                                         + " does not equal entry key "
 230                                                                         + contextSchemaEntry.getValue().getKey()));
 231                     }
 232
 233                     result = contextSchemaEntry.getValue().validate(result);
 234                 }
 235             }
 236         }
 237
 238         return result;
 239     }
 240
 241     /**
 242      * {@inheritDoc}.
 243      */
 244     @Override
 245     public void clean() {
 246         key.clean();
 247         for (final Entry<AxArtifactKey, AxContextSchema> contextSchemaEntry : schemas.entrySet()) {
 248             contextSchemaEntry.getKey().clean();
 249             contextSchemaEntry.getValue().clean();
 250         }
 251     }
 252
 253     /**
 254      * {@inheritDoc}.
 255      */
 256     @Override
 257     public String toString() {
 258         final StringBuilder builder = new StringBuilder();
 259         builder.append(this.getClass().getSimpleName());
 260         builder.append(":(");
 261         builder.append("key=");
 262         builder.append(key);
 263         builder.append(",schemas=");
 264         builder.append(schemas);
 265         builder.append(")");
 266         return builder.toString();
 267     }
 268
 269     /**
 270      * {@inheritDoc}.
 271      */
 272     @Override
 273     public AxConcept copyTo(final AxConcept target) {
 274         Assertions.argumentNotNull(target, "target may not be null");
 275
 276         final Object copyObject = target;
 277         Assertions.instanceOf(copyObject, AxContextSchemas.class);
 278
 279         final AxContextSchemas copy = ((AxContextSchemas) copyObject);
 280         copy.setKey(new AxArtifactKey(key));
 281
 282         final Map<AxArtifactKey, AxContextSchema> newcontextSchemas = new TreeMap<>();
 283         for (final Entry<AxArtifactKey, AxContextSchema> contextSchemasEntry : schemas.entrySet()) {
 284             newcontextSchemas.put(new AxArtifactKey(contextSchemasEntry.getKey()),
 285                             new AxContextSchema(contextSchemasEntry.getValue()));
 286         }
 287         copy.setSchemasMap(newcontextSchemas);
 288
 289         return copy;
 290     }
 291
 292     /**
 293      * {@inheritDoc}.
 294      */
 295     @Override
 296     public int hashCode() {
 297         final int prime = 31;
 298         int result = 1;
 299         result = prime * result + key.hashCode();
 300         result = prime * result + schemas.hashCode();
 301         return result;
 302     }
 303
 304     /**
 305      * {@inheritDoc}.
 306      */
 307     @Override
 308     public boolean equals(final Object obj) {
 309         if (obj == null) {
 310             return false;
 311         }
 312         if (this == obj) {
 313             return true;
 314         }
 315         if (getClass() != obj.getClass()) {
 316             return false;
 317         }
 318
 319         final AxContextSchemas other = (AxContextSchemas) obj;
 320         if (!key.equals(other.key)) {
 321             return false;
 322         }
 323         return schemas.equals(other.schemas);
 324     }
 325
 326     /**
 327      * {@inheritDoc}.
 328      */
 329     @Override
 330     public int compareTo(final AxConcept otherObj) {
 331         if (otherObj == null) {
 332             return -1;
 333         }
 334         if (this == otherObj) {
 335             return 0;
 336         }
 337         if (getClass() != otherObj.getClass()) {
 338             return this.hashCode() - otherObj.hashCode();
 339         }
 340
 341         final AxContextSchemas other = (AxContextSchemas) otherObj;
 342         if (!key.equals(other.key)) {
 343             return key.compareTo(other.key);
 344         }
 345         if (!schemas.equals(other.schemas)) {
 346             return (schemas.hashCode() - other.schemas.hashCode());
 347         }
 348
 349         return 0;
 350     }
 351
 352     /**
 353      * {@inheritDoc}.
 354      */
 355     @Override
 356     public AxContextSchema get(final AxArtifactKey conceptKey) {
 357         return new AxConceptGetterImpl<>((NavigableMap<AxArtifactKey, AxContextSchema>) schemas).get(conceptKey);
 358     }
 359
 360     /**
 361      * {@inheritDoc}.
 362      */
 363     @Override
 364     public AxContextSchema get(final String conceptKeyName) {
 365         return new AxConceptGetterImpl<>((NavigableMap<AxArtifactKey, AxContextSchema>) schemas).get(conceptKeyName);
 366     }
 367
 368     /**
 369      * {@inheritDoc}.
 370      */
 371     @Override
 372     public AxContextSchema get(final String conceptKeyName, final String conceptKeyVersion) {
 373         return new AxConceptGetterImpl<>((NavigableMap<AxArtifactKey, AxContextSchema>) schemas).get(conceptKeyName,
 374                         conceptKeyVersion);
 375     }
 376
 377     /**
 378      * {@inheritDoc}.
 379      */
 380     @Override
 381     public Set<AxContextSchema> getAll(final String conceptKeyName) {
 382         return new AxConceptGetterImpl<>((NavigableMap<AxArtifactKey, AxContextSchema>) schemas).getAll(conceptKeyName);
 383     }
 384
 385     /**
 386      * {@inheritDoc}.
 387      */
 388     @Override
 389     public Set<AxContextSchema> getAll(final String conceptKeyName, final String conceptKeyVersion) {
 390         return new AxConceptGetterImpl<>((NavigableMap<AxArtifactKey, AxContextSchema>) schemas).getAll(conceptKeyName,
 391                         conceptKeyVersion);
 392     }
 393 }