models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicy.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP Policy Model
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * Modifications Copyright (C) 2019-2020 Nordix Foundation.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  * SPDX-License-Identifier: Apache-2.0
  21  * ============LICENSE_END=========================================================
  22  */
  23
  24 package org.onap.policy.models.tosca.simple.concepts;
  25
  26 import java.util.ArrayList;
  27 import java.util.LinkedHashMap;
  28 import java.util.List;
  29 import java.util.Map;
  30 import java.util.Map.Entry;
  31
  32 import javax.persistence.AttributeOverride;
  33 import javax.persistence.AttributeOverrides;
  34 import javax.persistence.Column;
  35 import javax.persistence.ElementCollection;
  36 import javax.persistence.Entity;
  37 import javax.persistence.Inheritance;
  38 import javax.persistence.InheritanceType;
  39 import javax.persistence.Lob;
  40 import javax.persistence.Table;
  41 import javax.ws.rs.core.Response;
  42
  43 import lombok.Data;
  44 import lombok.EqualsAndHashCode;
  45 import lombok.NonNull;
  46
  47 import org.onap.policy.common.utils.coder.CoderException;
  48 import org.onap.policy.common.utils.coder.StandardCoder;
  49 import org.onap.policy.common.utils.validation.ParameterValidationUtils;
  50 import org.onap.policy.models.base.PfAuthorative;
  51 import org.onap.policy.models.base.PfConcept;
  52 import org.onap.policy.models.base.PfConceptKey;
  53 import org.onap.policy.models.base.PfKey;
  54 import org.onap.policy.models.base.PfModelRuntimeException;
  55 import org.onap.policy.models.base.PfUtils;
  56 import org.onap.policy.models.base.PfValidationMessage;
  57 import org.onap.policy.models.base.PfValidationResult;
  58 import org.onap.policy.models.base.PfValidationResult.ValidationResult;
  59 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
  60
  61 /**
  62  * Class to represent the policy in TOSCA definition.
  63  *
  64  * @author Chenfei Gao (cgao@research.att.com)
  65  * @author Liam Fallon (liam.fallon@est.tech)
  66  */
  67 @Entity
  68 @Table(name = "ToscaPolicy")
  69 @Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
  70 @Data
  71 @EqualsAndHashCode(callSuper = true)
  72 public class JpaToscaPolicy extends JpaToscaEntityType<ToscaPolicy> implements PfAuthorative<ToscaPolicy> {
  73     private static final long serialVersionUID = 3265174757061982805L;
  74
  75     // Tags for metadata
  76     private static final String METADATA_POLICY_ID_TAG = "policy-id";
  77     private static final String METADATA_POLICY_VERSION_TAG = "policy-version";
  78
  79     // @formatter:off
  80     @Column
  81     @AttributeOverrides({
  82         @AttributeOverride(name = "name",
  83                            column = @Column(name = "type_name")),
  84         @AttributeOverride(name = "version",
  85                            column = @Column(name = "type_version"))
  86         })
  87     private PfConceptKey type;
  88
  89     @ElementCollection
  90     @Lob
  91     private Map<String, String> properties;
  92
  93     @ElementCollection
  94     private List<PfConceptKey> targets = new ArrayList<>();
  95     // @formatter:on
  96
  97     /**
  98      * The Default Constructor creates a {@link JpaToscaPolicy} object with a null key.
  99      */
 100     public JpaToscaPolicy() {
 101         this(new PfConceptKey());
 102     }
 103
 104     /**
 105      * The Key Constructor creates a {@link JpaToscaPolicy} object with the given concept key.
 106      *
 107      * @param key the key
 108      */
 109     public JpaToscaPolicy(@NonNull final PfConceptKey key) {
 110         this(key, new PfConceptKey());
 111     }
 112
 113     /**
 114      * The full Constructor creates a {@link JpaToscaPolicy} object with all mandatory fields.
 115      *
 116      * @param key the key
 117      * @param type the type of the policy
 118      */
 119     public JpaToscaPolicy(@NonNull final PfConceptKey key, @NonNull final PfConceptKey type) {
 120         super(key);
 121         this.type = type;
 122     }
 123
 124     /**
 125      * Copy constructor.
 126      *
 127      * @param copyConcept the concept to copy from
 128      */
 129     public JpaToscaPolicy(@NonNull final JpaToscaPolicy copyConcept) {
 130         super(copyConcept);
 131         this.type = new PfConceptKey(copyConcept.type);
 132         this.properties = (copyConcept.properties != null ? new LinkedHashMap<>(copyConcept.properties) : null);
 133         this.targets = PfUtils.mapList(copyConcept.targets, PfConceptKey::new);
 134     }
 135
 136     /**
 137      * Authorative constructor.
 138      *
 139      * @param authorativeConcept the authorative concept to copy from
 140      */
 141     public JpaToscaPolicy(final ToscaPolicy authorativeConcept) {
 142         super(new PfConceptKey());
 143         type = new PfConceptKey();
 144         this.fromAuthorative(authorativeConcept);
 145     }
 146
 147     @Override
 148     public ToscaPolicy toAuthorative() {
 149         ToscaPolicy toscaPolicy = new ToscaPolicy();
 150         super.setToscaEntity(toscaPolicy);
 151         super.toAuthorative();
 152
 153         toscaPolicy.setType(type.getName());
 154
 155         if (!PfKey.NULL_KEY_VERSION.equals(type.getVersion())) {
 156             toscaPolicy.setTypeVersion(type.getVersion());
 157         } else {
 158             toscaPolicy.setTypeVersion(null);
 159         }
 160
 161         if (properties != null) {
 162             Map<String, Object> propertyMap = new LinkedHashMap<>();
 163
 164             final StandardCoder coder = new StandardCoder();
 165
 166             for (Entry<String, String> entry : properties.entrySet()) {
 167                 try {
 168                     // TODO: This is a HACK, we need to validate the properties against their
 169                     // TODO: their data type in their policy type definition in TOSCA, which means reading
 170                     // TODO: the policy type from the database and parsing the property value object correctly
 171                     // TODO: Here we are simply reading a JSON string from the database and deserializing the
 172                     // TODO: property value from JSON
 173                     propertyMap.put(entry.getKey(), coder.decode(entry.getValue(), Object.class));
 174                 } catch (CoderException ce) {
 175                     String errorMessage = "error decoding property JSON value read from database: key=" + entry.getKey()
 176                             + ", value=" + entry.getValue();
 177                     throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR, errorMessage, ce);
 178                 }
 179             }
 180
 181             toscaPolicy.setProperties(propertyMap);
 182         }
 183
 184         return toscaPolicy;
 185     }
 186
 187     @Override
 188     public void fromAuthorative(@NonNull final ToscaPolicy toscaPolicy) {
 189         super.fromAuthorative(toscaPolicy);
 190
 191         if (toscaPolicy.getType() != null) {
 192             type.setName(toscaPolicy.getType());
 193         } else {
 194             type.setName(PfKey.NULL_KEY_NAME);
 195         }
 196
 197         if (toscaPolicy.getTypeVersion() != null) {
 198             type.setVersion(toscaPolicy.getTypeVersion());
 199         } else {
 200             type.setVersion(PfKey.NULL_KEY_VERSION);
 201         }
 202
 203         if (toscaPolicy.getProperties() != null) {
 204             properties = new LinkedHashMap<>();
 205
 206             final StandardCoder coder = new StandardCoder();
 207
 208             for (Entry<String, Object> propertyEntry : toscaPolicy.getProperties().entrySet()) {
 209                 // TODO: This is a HACK, we need to validate the properties against their
 210                 // TODO: their data type in their policy type definition in TOSCA, which means reading
 211                 // TODO: the policy type from the database and parsing the property value object correctly
 212                 // TODO: Here we are simply serializing the property value into a string and storing it
 213                 // TODO: unvalidated into the database
 214                 try {
 215                     properties.put(propertyEntry.getKey(), coder.encode(propertyEntry.getValue()));
 216                 } catch (CoderException ce) {
 217                     String errorMessage = "error encoding property JSON value for database: key="
 218                             + propertyEntry.getKey() + ", value=" + propertyEntry.getValue();
 219                     throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR, errorMessage, ce);
 220                 }
 221             }
 222         }
 223
 224         // Add the property metadata if it doesn't exist already
 225         if (toscaPolicy.getMetadata() == null) {
 226             setMetadata(new LinkedHashMap<>());
 227         }
 228
 229         // Add the policy name and version fields to the metadata
 230         getMetadata().put(METADATA_POLICY_ID_TAG, getKey().getName());
 231         getMetadata().put(METADATA_POLICY_VERSION_TAG, Integer.toString(getKey().getMajorVersion()));
 232     }
 233
 234     @Override
 235     public List<PfKey> getKeys() {
 236         final List<PfKey> keyList = super.getKeys();
 237
 238         keyList.addAll(type.getKeys());
 239
 240         if (targets != null) {
 241             keyList.addAll(targets);
 242         }
 243
 244         return keyList;
 245     }
 246
 247     @Override
 248     public void clean() {
 249         super.clean();
 250
 251         type.clean();
 252
 253         if (targets != null) {
 254             for (PfConceptKey target : targets) {
 255                 target.clean();
 256             }
 257         }
 258     }
 259
 260     @Override
 261     public PfValidationResult validate(@NonNull final PfValidationResult resultIn) {
 262         PfValidationResult result = super.validate(resultIn);
 263
 264         if (type == null || type.isNullKey()) {
 265             result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
 266                     "type is null or a null key"));
 267         } else {
 268             result = type.validate(result);
 269         }
 270
 271         if (properties != null) {
 272             result = validateProperties(result);
 273         }
 274
 275         if (targets != null) {
 276             result = validateTargets(result);
 277         }
 278
 279         return result;
 280     }
 281
 282     /**
 283      * Validate the policy properties.
 284      *
 285      * @param result The result of validations up to now
 286      * @return the validation result
 287      */
 288     private PfValidationResult validateProperties(final PfValidationResult resultIn) {
 289         PfValidationResult result = resultIn;
 290
 291         for (Entry<String, String> propertyEntry : properties.entrySet()) {
 292             if (!ParameterValidationUtils.validateStringParameter(propertyEntry.getKey())) {
 293                 result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
 294                         "policy property key may not be null "));
 295             } else if (propertyEntry.getValue() == null) {
 296                 result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
 297                         "policy property value may not be null "));
 298             }
 299         }
 300         return result;
 301     }
 302
 303     /**
 304      * Validate the policy targets.
 305      *
 306      * @param result The result of validations up to now
 307      * @return the validation result
 308      */
 309     private PfValidationResult validateTargets(final PfValidationResult resultIn) {
 310         PfValidationResult result = resultIn;
 311
 312         for (PfConceptKey target : targets) {
 313             if (target == null) {
 314                 result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
 315                         "policy target may not be null "));
 316             } else {
 317                 result = target.validate(result);
 318             }
 319         }
 320         return result;
 321     }
 322
 323     @Override
 324     public int compareTo(final PfConcept otherConcept) {
 325         if (otherConcept == null) {
 326             return -1;
 327         }
 328
 329         if (this == otherConcept) {
 330             return 0;
 331         }
 332
 333         if (getClass() != otherConcept.getClass()) {
 334             return getClass().getName().compareTo(otherConcept.getClass().getName());
 335         }
 336
 337         final JpaToscaPolicy other = (JpaToscaPolicy) otherConcept;
 338         if (!super.equals(other)) {
 339             return super.compareTo(other);
 340         }
 341
 342         if (!type.equals(other.type)) {
 343             return type.compareTo(other.type);
 344         }
 345
 346         int retVal = PfUtils.compareObjects(properties, other.properties);
 347         if (retVal != 0) {
 348             return retVal;
 349         }
 350
 351         return PfUtils.compareObjects(targets, other.targets);
 352     }
 353 }