@EqualsAndHashCode(callSuper = false)
public class PfConceptContainer<C extends PfConcept, A extends PfNameVersion> extends PfConcept
- implements PfConceptGetter<C>, PfAuthorative<List<Map<String, A>>> {
+ implements PfConceptGetter<C>, PfAuthorative<List<Map<String, A>>> {
private static final long serialVersionUID = -324211738823208318L;
private static final Pattern KEY_ID_PATTERN = Pattern.compile(PfKey.KEY_ID_REGEXP);
}
incomingConceptEntry.getValue().setName(findConceptField(conceptKey, conceptKey.getName(),
- incomingConceptEntry.getValue(), PfNameVersion::getName));
+ incomingConceptEntry.getValue(), PfNameVersion::getName));
incomingConceptEntry.getValue().setVersion(findConceptField(conceptKey, conceptKey.getVersion(),
- incomingConceptEntry.getValue(), PfNameVersion::getVersion));
+ incomingConceptEntry.getValue(), PfNameVersion::getVersion));
C jpaConcept = getConceptNewInstance();
// This cast allows us to call the fromAuthorative method
if (conceptMap.isEmpty()) {
throw new PfModelRuntimeException(Response.Status.BAD_REQUEST,
- "An incoming list of concepts must have at least one entry");
+ "An incoming list of concepts must have at least one entry");
}
}
if (key.equals(PfConceptKey.getNullKey())) {
result.addValidationMessage(
- new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, "key is a null key"));
+ new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, "key is a null key"));
}
result = key.validate(result);
for (final Entry<PfConceptKey, C> conceptEntry : conceptMap.entrySet()) {
if (conceptEntry.getKey().equals(PfConceptKey.getNullKey())) {
result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "key on concept entry " + conceptEntry.getKey() + " may not be the null key"));
+ "key on concept entry " + conceptEntry.getKey() + " may not be the null key"));
} else if (conceptEntry.getValue() == null) {
result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "value on concept entry " + conceptEntry.getKey() + " may not be null"));
+ "value on concept entry " + conceptEntry.getKey() + " may not be null"));
} else if (!conceptEntry.getKey().equals(conceptEntry.getValue().getKey())) {
result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "key on concept entry key " + conceptEntry.getKey() + " does not equal concept value key "
- + conceptEntry.getValue().getKey()));
+ "key on concept entry key " + conceptEntry.getKey() + " does not equal concept value key "
+ + conceptEntry.getValue().getKey()));
result = conceptEntry.getValue().validate(result);
} else {
result = conceptEntry.getValue().validate(result);
return retVal;
}
- if (!conceptMap.equals(other.conceptMap)) {
- return (conceptMap.hashCode() - other.conceptMap.hashCode());
- }
-
- return 0;
+ return PfUtils.compareMaps(conceptMap, other.conceptMap);
}
/**
@Override
public C get(final String conceptKeyName, final String conceptKeyVersion) {
return new PfConceptGetterImpl<>((NavigableMap<PfConceptKey, C>) conceptMap).get(conceptKeyName,
- conceptKeyVersion);
+ conceptKeyVersion);
}
@Override
@Override
public Set<C> getAll(final String conceptKeyName, final String conceptKeyVersion) {
return new PfConceptGetterImpl<>((NavigableMap<PfConceptKey, C>) conceptMap).getAll(conceptKeyName,
- conceptKeyVersion);
+ conceptKeyVersion);
}
/**
private C getConceptNewInstance() {
try {
String conceptClassName =
- ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0].getTypeName();
+ ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0].getTypeName();
return (C) Class.forName(conceptClassName).getDeclaredConstructor().newInstance();
} catch (Exception ex) {
throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR,
- "failed to instantiate instance of container concept class", ex);
+ "failed to instantiate instance of container concept class", ex);
}
}
private String findConceptField(final PfConceptKey conceptKey, final String keyFieldValue,
- final PfNameVersion concept, final Function<PfNameVersion, String> fieldGetterFunction) {
+
final PfNameVersion concept, final Function<PfNameVersion, String> fieldGetterFunction) {
String conceptField = fieldGetterFunction.apply(concept);
return keyFieldValue;
} else {
throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, "Key " + conceptKey.getId() + " field "
- + keyFieldValue + " does not match the value " + conceptField + " in the concept field");
+ + keyFieldValue + " does not match the value " + conceptField + " in the concept field");
}
}
}
package org.onap.policy.models.base;
import java.lang.reflect.InvocationTargetException;
+import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import javax.ws.rs.core.Response;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.MapUtils;
/**
* Utility class for Policy Framework concept utilities.
return 0;
}
+ /**
+ * Compare two collections of the same type, nulls are allowed.
+ *
+ * @param leftCollection the first collection
+ * @param rightCollection the second collection
+ * @return a measure of the comparison
+ */
+ public static <T> int compareCollections(final Collection<T> leftCollection, final Collection<T> rightCollection) {
+ if (CollectionUtils.isEmpty(leftCollection) && CollectionUtils.isEmpty(rightCollection)) {
+ return 0;
+ }
+
+ return compareObjects(leftCollection, rightCollection);
+ }
+
+
+ /**
+ * Compare two maps of the same type, nulls are allowed.
+ *
+ * @param leftMap the first map
+ * @param rightMap the second map
+ * @return a measure of the comparison
+ */
+ public static <K, V> int compareMaps(final Map<K, V> leftMap, final Map<K, V> rightMap) {
+ if (MapUtils.isEmpty(leftMap) && MapUtils.isEmpty(rightMap)) {
+ return 0;
+ }
+
+ return compareObjects(leftMap, rightMap);
+ }
+
/**
* Convenience method to apply a mapping function to all of the elements of a list, generating a new list.
*
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019 Nordix Foundation.
+ * Copyright (C) 2019-2020 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* The ValidationResult enumeration describes the severity of a validation result.
*/
public enum ValidationResult {
- /** No problems or observations were detected during validation. */
- VALID,
- /**
- * Observations were made on a concept (such as blank descriptions) of a nature that will not
- * affect the use of the concept.
- */
- OBSERVATION,
- /**
- * Warnings were made on a concept (such as defined but unused concepts) of a nature that may
- * affect the use of the concept.
- */
- WARNING,
- /**
- * Errors were detected on a concept (such as referenced but undefined concepts) of a nature
- * that will affect the use of the concept.
- */
- INVALID
+ /** No problems or observations were detected during validation. */
+ VALID,
+ /**
+ * Observations were made on a concept (such as blank descriptions) of a nature that will not affect the use of
+ * the concept.
+ */
+ OBSERVATION,
+ /**
+ * Warnings were made on a concept (such as defined but unused concepts) of a nature that may affect the use of
+ * the concept.
+ */
+ WARNING,
+ /**
+ * Errors were detected on a concept (such as referenced but undefined concepts) of a nature that will affect
+ * the use of the concept.
+ */
+ INVALID
}
// The actual verification result
private final List<PfValidationMessage> messageList = new LinkedList<>();
/**
- * Check if a validation reported a valid concept, returns true if the model is usable (that is,
- * even if the model has warnings or observations).
+ * Check if a validation reported a valid concept, returns true if the model is usable (that is, even if the model
+ * has warnings or observations).
*
* @return true, if the concept is reported as valid and can be used
*/
}
/**
- * Check if a validation reported a concept with no errors or warnings, returns true if the
- * model is OK to use.
+ * Check if a validation reported a concept with no errors or warnings, returns true if the model is OK to use.
*
* @return true, if the concept has no warnings or errors
*/
return validationResult == ValidationResult.VALID || validationResult == ValidationResult.OBSERVATION;
}
+
+ /**
+ * Append a validation result to another validation result.
+ *
+ * @param result2Append the result to append to the current validation result
+ */
+ public void append(final PfValidationResult result2Append) {
+ for (PfValidationMessage message : result2Append.getMessageList()) {
+ addValidationMessage(message);
+ }
+ }
+
/**
- * Adds a validation message to the validation result, used by validate() implementations on
- * {@link PfConcept} subclasses to report validaiton observations.
+ * Adds a validation message to the validation result, used by validate() implementations on {@link PfConcept}
+ * subclasses to report validaiton observations.
*
* @param validationMessage the validation message
*/
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019 Nordix Foundation.
+ * Copyright (C) 2019-2020 Nordix Foundation.
* Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
private static final String SOME_MESSAGE = "Some message";
@Test
- public void test() {
+ public void testValidation1() {
PfValidationResult result = new PfValidationResult();
PfConceptKey pfKeyey = new PfConceptKey("PK", "0.0.1");
result = pfKeyey.validate(result);
assertNotNull(result.getMessageList());
PfValidationMessage vmess0 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class,
- ValidationResult.VALID, SOME_MESSAGE);
+ ValidationResult.VALID, SOME_MESSAGE);
result.addValidationMessage(vmess0);
assertTrue(result.isOk());
assertNotNull(HELLO, result.toString());
PfValidationMessage vmess1 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class,
- ValidationResult.OBSERVATION, SOME_MESSAGE);
+ ValidationResult.OBSERVATION, SOME_MESSAGE);
result.addValidationMessage(vmess1);
assertTrue(result.isOk());
assertEquals(PfValidationResult.ValidationResult.OBSERVATION, result.getValidationResult());
assertNotNull(result.getMessageList());
assertNotNull(HELLO, result.toString());
+ }
+
+
+ @Test
+ public void testValidation2() {
+ PfValidationResult result = new PfValidationResult();
PfValidationMessage vmess2 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class,
- ValidationResult.WARNING, SOME_MESSAGE);
+ ValidationResult.WARNING, SOME_MESSAGE);
result.addValidationMessage(vmess2);
assertFalse(result.isOk());
assertNotNull(HELLO, result.toString());
PfValidationMessage vmess3 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class,
- ValidationResult.INVALID, SOME_MESSAGE);
+ ValidationResult.INVALID, SOME_MESSAGE);
result.addValidationMessage(vmess3);
assertFalse(result.isOk());
assertNotNull(result.getMessageList());
assertNotNull(HELLO, result.toString());
- assertEquals(PfValidationResult.ValidationResult.INVALID, result.getMessageList().get(3).getValidationResult());
- assertEquals(SOME_MESSAGE, result.getMessageList().get(3).getMessage());
- assertEquals(PfConceptKey.class.getName(), result.getMessageList().get(3).getObservedClass());
- assertEquals(PfConceptKey.getNullKey(), result.getMessageList().get(3).getObservedKey());
+ assertEquals(PfValidationResult.ValidationResult.INVALID, result.getMessageList().get(1).getValidationResult());
+ assertEquals(SOME_MESSAGE, result.getMessageList().get(1).getMessage());
+ assertEquals(PfConceptKey.class.getName(), result.getMessageList().get(1).getObservedClass());
+ assertEquals(PfConceptKey.getNullKey(), result.getMessageList().get(1).getObservedKey());
+ }
+
+ @Test
+ public void testValidationAppend() {
+ PfValidationResult result = new PfValidationResult();
+
+ PfValidationResult result2 = new PfValidationResult();
+ PfValidationMessage vmess1 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class,
+ ValidationResult.OBSERVATION, "Message 1");
+ result2.addValidationMessage(vmess1);
+
+ result.append(result2);
+ assertEquals(1, result.getMessageList().size());
+ assertEquals(ValidationResult.OBSERVATION, result.getValidationResult());
+
+ PfValidationResult result3 = new PfValidationResult();
+ PfValidationMessage vmess2 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class,
+ ValidationResult.WARNING, "Message 2");
+ result3.addValidationMessage(vmess2);
+ result.append(result3);
+ assertEquals(2, result.getMessageList().size());
+ assertEquals(ValidationResult.WARNING, result.getValidationResult());
+
+ PfValidationResult result4 = new PfValidationResult();
+ PfValidationMessage vmess3 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class,
+ ValidationResult.INVALID, "Message 3");
+ PfValidationMessage vmess4 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class,
+ ValidationResult.VALID, "Message 4");
+ result4.addValidationMessage(vmess3);
+ result4.addValidationMessage(vmess4);
+ result.append(result4);
+ assertEquals(4, result.getMessageList().size());
+ assertEquals(ValidationResult.INVALID, result.getValidationResult());
}
}
<persistence-unit name="ToscaConceptTest" transaction-type="RESOURCE_LOCAL">
<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
+ <class>org.onap.policy.models.base.PfConceptKey</class>
<class>org.onap.policy.models.dao.converters.CDataConditioner</class>
<class>org.onap.policy.models.dao.converters.Uuid2String</class>
- <class>org.onap.policy.models.base.PfConceptKey</class>
+ <class>org.onap.policy.models.pdp.persistence.concepts.JpaPdp</class>
+ <class>org.onap.policy.models.pdp.persistence.concepts.JpaPdpGroup</class>
+ <class>org.onap.policy.models.pdp.persistence.concepts.JpaPdpStatistics</class>
+ <class>org.onap.policy.models.pdp.persistence.concepts.JpaPdpSubGroup</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaCapabilityAssignment</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaCapabilityAssignments</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaCapabilityType</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaCapabilityTypes</class>
<class>org.onap.policy.models.tosca.simple.concepts.JpaToscaDataType</class>
<class>org.onap.policy.models.tosca.simple.concepts.JpaToscaDataTypes</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTemplate</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTemplates</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeType</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTypes</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaParameter</class>
<class>org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicies</class>
<class>org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicy</class>
<class>org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicyType</class>
<class>org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicyTypes</class>
- <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaTopologyTemplate</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaProperty</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaRelationshipType</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaRelationshipTypes</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaRequirement</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaRequirements</class>
<class>org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaTopologyTemplate</class>
<class>org.onap.policy.models.tosca.simple.concepts.JpaToscaTrigger</class>
- <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaProperty</class>
- <class>org.onap.policy.models.pdp.persistence.concepts.JpaPdpGroup</class>
- <class>org.onap.policy.models.pdp.persistence.concepts.JpaPdpSubGroup</class>
- <class>org.onap.policy.models.pdp.persistence.concepts.JpaPdp</class>
- <class>org.onap.policy.models.pdp.persistence.concepts.JpaPdpStatistics</class>
<properties>
<property name="eclipselink.ddl-generation" value="drop-and-create-tables" />
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2020 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.models.tosca.simple.concepts;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import javax.persistence.ElementCollection;
+import javax.persistence.Entity;
+import javax.persistence.Inheritance;
+import javax.persistence.InheritanceType;
+import javax.persistence.Lob;
+import javax.persistence.Table;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import org.onap.policy.common.utils.coder.YamlJsonTranslator;
+import org.onap.policy.models.base.PfAuthorative;
+import org.onap.policy.models.base.PfConcept;
+import org.onap.policy.models.base.PfConceptKey;
+import org.onap.policy.models.base.PfUtils;
+import org.onap.policy.models.base.PfValidationMessage;
+import org.onap.policy.models.base.PfValidationResult;
+import org.onap.policy.models.base.PfValidationResult.ValidationResult;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaCapabilityAssignment;
+
+/**
+ * Class to represent the parameter in TOSCA definition.
+ */
+@Entity
+@Table(name = "ToscaCapabilityAssignment")
+@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class JpaToscaCapabilityAssignment extends JpaToscaEntityType<ToscaCapabilityAssignment>
+ implements PfAuthorative<ToscaCapabilityAssignment> {
+
+ private static final long serialVersionUID = 1675770231921107988L;
+
+ private static final String AUTHORATIVE_UNBOUNDED_LITERAL = "UNBOUNDED";
+ private static final Integer JPA_UNBOUNDED_VALUE = -1;
+
+ private static final YamlJsonTranslator YAML_JSON_TRANSLATOR = new YamlJsonTranslator();
+
+ @ElementCollection
+ @Lob
+ private Map<String, String> properties;
+
+ @ElementCollection
+ @Lob
+ private Map<String, String> attributes;
+
+ @ElementCollection
+ private List<Integer> occurrences;
+
+ /**
+ * The Default Constructor creates a {@link JpaToscaCapabilityAssignment} object with a null key.
+ */
+ public JpaToscaCapabilityAssignment() {
+ this(new PfConceptKey());
+ }
+
+ /**
+ * The Key Constructor creates a {@link JpaToscaCapabilityAssignment} object with the given concept key.
+ *
+ * @param key the key
+ */
+ public JpaToscaCapabilityAssignment(@NonNull final PfConceptKey key) {
+ super(key);
+ }
+
+ /**
+ * Copy constructor.
+ *
+ * @param copyConcept the concept to copy from
+ */
+ public JpaToscaCapabilityAssignment(final JpaToscaCapabilityAssignment copyConcept) {
+ super(copyConcept);
+ this.properties = copyConcept.properties == null ? null : new LinkedHashMap<>(copyConcept.properties);
+ this.attributes = copyConcept.attributes == null ? null : new LinkedHashMap<>(copyConcept.attributes);
+ this.occurrences = copyConcept.occurrences == null ? null : new ArrayList<>(copyConcept.occurrences);
+ }
+
+ /**
+ * Authorative constructor.
+ *
+ * @param authorativeConcept the authorative concept to copy from
+ */
+ public JpaToscaCapabilityAssignment(@NonNull final ToscaCapabilityAssignment authorativeConcept) {
+ super(new PfConceptKey());
+ this.fromAuthorative(authorativeConcept);
+ }
+
+ @Override
+ public ToscaCapabilityAssignment toAuthorative() {
+ ToscaCapabilityAssignment toscaCapabilityAssignment = new ToscaCapabilityAssignment();
+ super.setToscaEntity(toscaCapabilityAssignment);
+ super.toAuthorative();
+
+ toscaCapabilityAssignment.setProperties(
+ PfUtils.mapMap(properties, property -> YAML_JSON_TRANSLATOR.fromYaml(property, Object.class)));
+
+ toscaCapabilityAssignment.setAttributes(
+ PfUtils.mapMap(attributes, attribute -> YAML_JSON_TRANSLATOR.fromYaml(attribute, Object.class)));
+
+ toscaCapabilityAssignment.setOccurrences(PfUtils.mapList(occurrences, occurrence -> {
+ if (occurrence.equals(JPA_UNBOUNDED_VALUE)) {
+ return AUTHORATIVE_UNBOUNDED_LITERAL;
+ } else {
+ return occurrence;
+ }
+ }));
+
+ return toscaCapabilityAssignment;
+ }
+
+ @Override
+ public void fromAuthorative(ToscaCapabilityAssignment toscaCapabilityAssignment) {
+ super.fromAuthorative(toscaCapabilityAssignment);
+
+
+ properties = PfUtils.mapMap(toscaCapabilityAssignment.getProperties(), YAML_JSON_TRANSLATOR::toYaml);
+ attributes = PfUtils.mapMap(toscaCapabilityAssignment.getAttributes(), YAML_JSON_TRANSLATOR::toYaml);
+
+ occurrences = PfUtils.mapList(toscaCapabilityAssignment.getOccurrences(), occurrence -> {
+ if (occurrence.equals(AUTHORATIVE_UNBOUNDED_LITERAL)) {
+ return JPA_UNBOUNDED_VALUE;
+ } else {
+ return ((Number) occurrence).intValue();
+ }
+ });
+ }
+
+ @Override
+ public void clean() {
+ super.clean();
+
+ properties = PfUtils.mapMap(properties, String::trim);
+ attributes = PfUtils.mapMap(attributes, String::trim);
+ }
+
+ @Override
+ public PfValidationResult validate(final PfValidationResult resultIn) {
+ PfValidationResult result = super.validate(resultIn);
+
+ if (properties != null) {
+ result.append(validateProperties(new PfValidationResult()));
+ }
+
+ if (attributes != null) {
+ result.append(validateAttributes(new PfValidationResult()));
+ }
+
+ if (occurrences != null) {
+ result.append(validateOccurrences(new PfValidationResult()));
+ }
+
+ return result;
+ }
+
+ /**
+ * Validate the properties.
+ *
+ * @param resultIn The result of validations up to now
+ * @return the validation result
+ */
+ private PfValidationResult validateProperties(final PfValidationResult resultIn) {
+ PfValidationResult result = resultIn;
+
+ for (Entry<String, String> propertyEntry : properties.entrySet()) {
+ if (propertyEntry.getValue() == null) {
+ result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
+ "capability assignment property " + propertyEntry.getKey() + " value may not be null"));
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Validate the attributes.
+ *
+ * @param resultIn The result of validations up to now
+ * @return the validation result
+ */
+ private PfValidationResult validateAttributes(final PfValidationResult resultIn) {
+ PfValidationResult result = resultIn;
+
+ for (Entry<String, String> attributeEntry : attributes.entrySet()) {
+ if (attributeEntry.getValue() == null) {
+ result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
+ "capability assignment attribute " + attributeEntry.getKey() + " value may not be null"));
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Validate the occurrences.
+ *
+ * @param resultIn The result of validations up to now
+ * @return the validation result
+ */
+ private PfValidationResult validateOccurrences(final PfValidationResult resultIn) {
+ PfValidationResult result = resultIn;
+
+ for (Integer occurrence : occurrences) {
+ if (occurrence == null) {
+ result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
+ "capability assignment occurrence value may not be null "));
+ } else if (occurrence < 0 && !occurrence.equals(JPA_UNBOUNDED_VALUE)) {
+ result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
+ "capability assignment occurrence value may not be negative"));
+ }
+ }
+
+ return result;
+ }
+
+ @Override
+ public int compareTo(final PfConcept otherConcept) {
+ if (otherConcept == null) {
+ return -1;
+ }
+
+ if (this == otherConcept) {
+ return 0;
+ }
+
+ if (getClass() != otherConcept.getClass()) {
+ return getClass().getName().compareTo(otherConcept.getClass().getName());
+ }
+
+ final JpaToscaCapabilityAssignment other = (JpaToscaCapabilityAssignment) otherConcept;
+ int result = super.compareTo(other);
+ if (result != 0) {
+ return result;
+ }
+
+ result = PfUtils.compareMaps(properties, other.properties);
+ if (result != 0) {
+ return result;
+ }
+
+ result = PfUtils.compareMaps(attributes, other.attributes);
+ if (result != 0) {
+ return result;
+ }
+
+ return PfUtils.compareCollections(occurrences, other.occurrences);
+ }
+}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2020 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.models.tosca.simple.concepts;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import javax.persistence.Entity;
+import javax.persistence.Inheritance;
+import javax.persistence.InheritanceType;
+import javax.persistence.Table;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import lombok.ToString;
+import org.onap.policy.models.base.PfAuthorative;
+import org.onap.policy.models.base.PfConceptContainer;
+import org.onap.policy.models.base.PfConceptKey;
+import org.onap.policy.models.base.PfValidationResult;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaCapabilityAssignment;
+import org.onap.policy.models.tosca.utils.ToscaUtils;
+
+/**
+ * This class is a container for TOSCA capability assignments.
+ *
+ * @author Liam Fallon (liam.fallon@est.tech)
+ */
+@Entity
+@Table(name = "ToscaCapabilityAssignments")
+@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
+@Data
+@ToString(callSuper = true)
+@EqualsAndHashCode(callSuper = true)
+public class JpaToscaCapabilityAssignments
+ extends PfConceptContainer<JpaToscaCapabilityAssignment, ToscaCapabilityAssignment>
+ implements PfAuthorative<List<Map<String, ToscaCapabilityAssignment>>> {
+ public static final String DEFAULT_NAME = "ToscaCapabilityAssignmentsSimple";
+ public static final String DEFAULT_VERSION = "1.0.0";
+ private static final long serialVersionUID = -7526648702327776101L;
+
+ /**
+ * The Default Constructor creates a {@link JpaToscaCapabilityAssignments} object with a null
+ * artifact key and creates an empty concept map.
+ */
+ public JpaToscaCapabilityAssignments() {
+ super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION));
+ }
+
+ /**
+ * The Key Constructor creates a {@link JpaToscaCapabilityAssignments} object with the given
+ * artifact key and creates an empty concept map.
+ *
+ * @param key the concept key
+ */
+ public JpaToscaCapabilityAssignments(final PfConceptKey key) {
+ super(key, new TreeMap<>());
+ }
+
+ /**
+ * This Constructor creates an concept container with all of its fields defined.
+ *
+ * @param key the concept container key
+ * @param conceptMap the concepts to be stored in the concept container
+ */
+ public JpaToscaCapabilityAssignments(final PfConceptKey key,
+ final Map<PfConceptKey, JpaToscaCapabilityAssignment> conceptMap) {
+ super(key, conceptMap);
+ }
+
+ /**
+ * Copy constructor.
+ *
+ * @param copyConcept the concept to copy from
+ */
+ public JpaToscaCapabilityAssignments(final JpaToscaCapabilityAssignments copyConcept) {
+ super(copyConcept);
+ }
+
+ /**
+ * Authorative constructor.
+ *
+ * @param authorativeConceptMapList the authorative concept to copy from
+ */
+ public JpaToscaCapabilityAssignments(final List<Map<String, ToscaCapabilityAssignment>> authorativeConceptMapList) {
+ super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION));
+ this.fromAuthorative(authorativeConceptMapList);
+ }
+
+ @Override
+ public PfValidationResult validate(@NonNull final PfValidationResult resultIn) {
+ PfValidationResult result = super.validate(resultIn);
+
+ for (JpaToscaCapabilityAssignment assignment : this.getConceptMap().values()) {
+ ToscaUtils.getEntityTypeAncestors(this, assignment, result);
+ }
+
+ return result;
+ }
+}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2020 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.models.tosca.simple.concepts;
+
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import javax.persistence.ElementCollection;
+import javax.persistence.Entity;
+import javax.persistence.Inheritance;
+import javax.persistence.InheritanceType;
+import javax.persistence.Lob;
+import javax.persistence.Table;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import org.apache.commons.collections4.CollectionUtils;
+import org.onap.policy.models.base.PfAuthorative;
+import org.onap.policy.models.base.PfConcept;
+import org.onap.policy.models.base.PfConceptKey;
+import org.onap.policy.models.base.PfKey;
+import org.onap.policy.models.base.PfReferenceKey;
+import org.onap.policy.models.base.PfUtils;
+import org.onap.policy.models.base.PfValidationMessage;
+import org.onap.policy.models.base.PfValidationResult;
+import org.onap.policy.models.base.PfValidationResult.ValidationResult;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaCapabilityType;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaProperty;
+import org.onap.policy.models.tosca.utils.ToscaUtils;
+
+/**
+ * Class to represent the capability type in TOSCA definition.
+ */
+
+@Entity
+@Table(name = "ToscaCapabilityType")
+@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class JpaToscaCapabilityType extends JpaToscaEntityType<ToscaCapabilityType>
+ implements PfAuthorative<ToscaCapabilityType> {
+ private static final long serialVersionUID = -563659852901842616L;
+
+ @ElementCollection
+ @Lob
+ private Map<String, JpaToscaProperty> properties;
+
+ /**
+ * The Default Constructor creates a {@link JpaToscaCapabilityType} object with a null key.
+ */
+ public JpaToscaCapabilityType() {
+ this(new PfConceptKey());
+ }
+
+ /**
+ * The Key Constructor creates a {@link JpaToscaCapabilityType} object with the given concept key.
+ *
+ * @param key the key
+ */
+ public JpaToscaCapabilityType(@NonNull final PfConceptKey key) {
+ super(key);
+ }
+
+ /**
+ * Copy constructor.
+ *
+ * @param copyConcept the concept to copy from
+ */
+ public JpaToscaCapabilityType(final JpaToscaCapabilityType copyConcept) {
+ super(copyConcept);
+ this.properties = copyConcept.properties == null ? null : new LinkedHashMap<>(copyConcept.properties);
+ }
+
+ /**
+ * Authorative constructor.
+ *
+ * @param authorativeConcept the authorative concept to copy from
+ */
+ public JpaToscaCapabilityType(final ToscaCapabilityType authorativeConcept) {
+ this.fromAuthorative(authorativeConcept);
+ }
+
+ @Override
+ public ToscaCapabilityType toAuthorative() {
+ ToscaCapabilityType toscaCapabilityType = new ToscaCapabilityType();
+ super.setToscaEntity(toscaCapabilityType);
+ super.toAuthorative();
+
+ toscaCapabilityType.setProperties(PfUtils.mapMap(properties, JpaToscaProperty::toAuthorative));
+
+ return toscaCapabilityType;
+ }
+
+ @Override
+ public void fromAuthorative(final ToscaCapabilityType toscaCapabilityType) {
+ super.fromAuthorative(toscaCapabilityType);
+
+ // Set properties
+ if (toscaCapabilityType.getProperties() != null) {
+ properties = new LinkedHashMap<>();
+ for (Entry<String, ToscaProperty> toscaPropertyEntry : toscaCapabilityType.getProperties().entrySet()) {
+ JpaToscaProperty jpaProperty = new JpaToscaProperty(toscaPropertyEntry.getValue());
+ jpaProperty.setKey(new PfReferenceKey(getKey(), toscaPropertyEntry.getKey()));
+ properties.put(toscaPropertyEntry.getKey(), jpaProperty);
+ }
+ }
+ }
+
+ @Override
+ public List<PfKey> getKeys() {
+ final List<PfKey> keyList = super.getKeys();
+
+ PfUtils.mapMap(properties, property -> keyList.addAll(property.getKeys()));
+
+
+ if (properties != null) {
+ for (JpaToscaProperty property : properties.values()) {
+ keyList.addAll(property.getKeys());
+ }
+ }
+
+ return keyList;
+ }
+
+ @Override
+ public void clean() {
+ super.clean();
+
+ if (properties != null) {
+ for (JpaToscaProperty property : properties.values()) {
+ property.clean();
+ }
+ }
+ }
+
+ @Override
+ public PfValidationResult validate(@NonNull final PfValidationResult resultIn) {
+ PfValidationResult result = super.validate(resultIn);
+
+ if (getKey().isNullVersion()) {
+ result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
+ "key version is a null version"));
+ }
+
+ if (properties != null) {
+ result = validateProperties(result);
+ }
+
+ return result;
+ }
+
+ /**
+ * Validate the capabiltiy type properties.
+ *
+ * @param resultIn The result of validations up to now
+ * @return the validation result
+ */
+ private PfValidationResult validateProperties(final PfValidationResult resultIn) {
+ PfValidationResult result = resultIn;
+
+ for (JpaToscaProperty property : properties.values()) {
+ if (property == null) {
+ result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
+ "capability type property may not be null "));
+ } else {
+ result = property.validate(result);
+ }
+ }
+ return result;
+ }
+
+ @Override
+ public int compareTo(final PfConcept otherConcept) {
+ if (otherConcept == null) {
+ return -1;
+ }
+ if (this == otherConcept) {
+ return 0;
+ }
+ if (getClass() != otherConcept.getClass()) {
+ return getClass().getName().compareTo(otherConcept.getClass().getName());
+ }
+
+ final JpaToscaCapabilityType other = (JpaToscaCapabilityType) otherConcept;
+ int result = super.compareTo(other);
+ if (result != 0) {
+ return result;
+ }
+
+ return PfUtils.compareMaps(properties, other.properties);
+ }
+
+ /**
+ * Get the data types referenced in a capability type.
+ *
+ * @return the data types referenced in a capability type
+ */
+ public Collection<PfConceptKey> getReferencedDataTypes() {
+ if (properties == null) {
+ return CollectionUtils.emptyCollection();
+ }
+
+ Set<PfConceptKey> referencedDataTypes = new LinkedHashSet<>();
+
+ for (JpaToscaProperty property : properties.values()) {
+ referencedDataTypes.add(property.getType());
+
+ if (property.getEntrySchema() != null) {
+ referencedDataTypes.add(property.getEntrySchema().getType());
+ }
+ }
+
+ referencedDataTypes.removeAll(ToscaUtils.getPredefinedDataTypes());
+
+ return referencedDataTypes;
+ }
+}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2020 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.models.tosca.simple.concepts;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import javax.persistence.Entity;
+import javax.persistence.Inheritance;
+import javax.persistence.InheritanceType;
+import javax.persistence.Table;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import lombok.ToString;
+import org.onap.policy.models.base.PfConceptContainer;
+import org.onap.policy.models.base.PfConceptKey;
+import org.onap.policy.models.base.PfValidationResult;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaCapabilityType;
+import org.onap.policy.models.tosca.utils.ToscaUtils;
+
+/**
+ * This class is a container for TOSCA capability types.
+ */
+@Entity
+@Table(name = "ToscaCapabilityTypes")
+@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
+@Data
+@ToString(callSuper = true)
+@EqualsAndHashCode(callSuper = true)
+public class JpaToscaCapabilityTypes extends PfConceptContainer<JpaToscaCapabilityType, ToscaCapabilityType> {
+ public static final String DEFAULT_NAME = "ToscaCapabilityTypesSimple";
+ public static final String DEFAULT_VERSION = "1.0.0";
+ private static final long serialVersionUID = -4157979965271220098L;
+
+ /**
+ * The Default Constructor creates a {@link JpaToscaCapabilityTypes} object with a null artifact key and creates an
+ * empty concept map.
+ */
+ public JpaToscaCapabilityTypes() {
+ super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION));
+ }
+
+ /**
+ * The Key Constructor creates a {@link JpaToscaCapabilityTypes} object with the given artifact key and creates an
+ * empty concept map.
+ *
+ * @param key the concept key
+ */
+ public JpaToscaCapabilityTypes(final PfConceptKey key) {
+ super(key, new TreeMap<>());
+ }
+
+ /**
+ * This Constructor creates an concept container with all of its fields defined.
+ *
+ * @param key the concept container key
+ * @param conceptMap the concepts to be stored in the concept container
+ */
+ public JpaToscaCapabilityTypes(final PfConceptKey key, final Map<PfConceptKey, JpaToscaCapabilityType> conceptMap) {
+ super(key, conceptMap);
+ }
+
+ /**
+ * Copy constructor.
+ *
+ * @param copyConcept the concept to copy from
+ */
+ public JpaToscaCapabilityTypes(final JpaToscaCapabilityTypes copyConcept) {
+ super(copyConcept);
+ }
+
+ /**
+ * Authorative constructor.
+ *
+ * @param authorativeConceptMapList the authorative concept to copy from
+ */
+ public JpaToscaCapabilityTypes(final List<Map<String, ToscaCapabilityType>> authorativeConceptMapList) {
+ super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION));
+ this.fromAuthorative(authorativeConceptMapList);
+ }
+
+ @Override
+ public PfValidationResult validate(@NonNull final PfValidationResult resultIn) {
+ PfValidationResult result = super.validate(resultIn);
+
+ // Check that all ancestors of this policy type exist
+ for (JpaToscaCapabilityType capabilityType : this.getConceptMap().values()) {
+ ToscaUtils.getEntityTypeAncestors(this, capabilityType, result);
+ }
+
+ return result;
+ }
+}
import org.onap.policy.models.base.PfValidationMessage;
import org.onap.policy.models.base.PfValidationResult;
import org.onap.policy.models.base.PfValidationResult.ValidationResult;
-import org.onap.policy.models.tosca.authorative.concepts.ToscaConstraint;
import org.onap.policy.models.tosca.authorative.concepts.ToscaDataType;
import org.onap.policy.models.tosca.authorative.concepts.ToscaProperty;
import org.onap.policy.models.tosca.utils.ToscaUtils;
private static final long serialVersionUID = -3922690413436539164L;
@ElementCollection
- private List<JpaToscaConstraint> constraints = new ArrayList<>();
+ private List<JpaToscaConstraint> constraints;
@ElementCollection
@Lob
- private Map<String, JpaToscaProperty> properties = new LinkedHashMap<>();
+ private Map<String, JpaToscaProperty> properties;
/**
* The Default Constructor creates a {@link JpaToscaDataType} object with a null key.
super.setToscaEntity(toscaDataType);
super.toAuthorative();
- if (constraints != null) {
- List<ToscaConstraint> toscaConstraints = new ArrayList<>();
-
- for (JpaToscaConstraint constraint : constraints) {
- toscaConstraints.add(constraint.toAuthorative());
- }
-
- toscaDataType.setConstraints(toscaConstraints);
- }
-
- if (properties != null) {
- Map<String, ToscaProperty> propertyMap = new LinkedHashMap<>();
-
- for (Entry<String, JpaToscaProperty> entry : properties.entrySet()) {
- propertyMap.put(entry.getKey(), entry.getValue().toAuthorative());
- }
-
- toscaDataType.setProperties(propertyMap);
- }
+ toscaDataType.setConstraints(PfUtils.mapList(constraints, JpaToscaConstraint::toAuthorative));
+ toscaDataType.setProperties(PfUtils.mapMap(properties, JpaToscaProperty::toAuthorative));
return toscaDataType;
}
public void fromAuthorative(final ToscaDataType toscaDataType) {
super.fromAuthorative(toscaDataType);
- if (toscaDataType.getConstraints() != null) {
- constraints = new ArrayList<>();
-
- for (ToscaConstraint toscaConstraint : toscaDataType.getConstraints()) {
- constraints.add(JpaToscaConstraint.newInstance(toscaConstraint));
- }
- }
+ constraints = PfUtils.mapList(toscaDataType.getConstraints(), JpaToscaConstraint::newInstance);
if (toscaDataType.getProperties() != null) {
properties = new LinkedHashMap<>();
/**
* Validate the properties.
*
- * @param result The result of validations up to now
+ * @param resultIn The result of validations up to now
* @return the validation result
*/
private PfValidationResult validateProperties(final PfValidationResult resultIn) {
}
final JpaToscaDataType other = (JpaToscaDataType) otherConcept;
- if (!super.equals(other)) {
- return super.compareTo(other);
- }
-
- int result = PfUtils.compareObjects(constraints, other.constraints);
+ int result = super.compareTo(other);
if (result != 0) {
return result;
}
- result = PfUtils.compareObjects(properties, other.properties);
+ result = PfUtils.compareCollections(constraints, other.constraints);
if (result != 0) {
return result;
}
- return 0;
+ return PfUtils.compareMaps(properties, other.properties);
}
/**
package org.onap.policy.models.tosca.simple.concepts;
-import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
private PfConceptKey derivedFrom;
@ElementCollection
- private Map<String, String> metadata = new TreeMap<>();
+ private Map<String, String> metadata;
@Column
private String description;
toscaEntity.setDescription(description);
}
- if (metadata != null) {
- Map<String, String> metadataMap = new LinkedHashMap<>();
-
- for (Entry<String, String> entry : metadata.entrySet()) {
- metadataMap.put(entry.getKey(), entry.getValue());
- }
-
- toscaEntity.setMetadata(metadataMap);
- }
+ toscaEntity.setMetadata(PfUtils.mapMap(metadata, item -> item));
return toscaEntity;
}
}
if (toscaEntity.getDerivedFrom() != null) {
- // CHeck if the derived from field contains a name-version ID
+ // Check if the derived from field contains a name-version ID
if (toscaEntity.getDerivedFrom().contains(":")) {
derivedFrom = new PfConceptKey(toscaEntity.getDerivedFrom());
} else {
description = toscaEntity.getDescription();
}
- if (toscaEntity.getMetadata() != null) {
- metadata = new LinkedHashMap<>();
-
- for (Entry<String, String> metadataEntry : toscaEntity.getMetadata().entrySet()) {
- metadata.put(metadataEntry.getKey(), metadataEntry.getValue());
- }
- }
+ metadata = PfUtils.mapMap(toscaEntity.getMetadata(), item -> item);
}
@Override
@SuppressWarnings("unchecked")
final JpaToscaEntityType<T> other = (JpaToscaEntityType<T>) otherConcept;
- if (!key.equals(other.key)) {
- return key.compareTo(other.key);
+
+ int result = key.compareTo(other.key);
+ if (result != 0) {
+ return result;
}
- int result = ObjectUtils.compare(derivedFrom, other.derivedFrom);
+ result = ObjectUtils.compare(derivedFrom, other.derivedFrom);
if (result != 0) {
return result;
}
- result = PfUtils.compareObjects(metadata, other.metadata);
+ result = PfUtils.compareMaps(metadata, other.metadata);
if (result != 0) {
return result;
}
* ONAP Policy Model
* ================================================================================
* Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2019 Nordix Foundation.
+ * Modifications Copyright (C) 2019-2020 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
}
final JpaToscaEventFilter other = (JpaToscaEventFilter) otherConcept;
- if (!key.equals(other.key)) {
- return key.compareTo(other.key);
+ int result = key.compareTo(other.key);
+ if (result != 0) {
+ return result;
}
- if (!node.equals(other.node)) {
- return node.compareTo(other.node);
+ result = node.compareTo(other.node);
+ if (result != 0) {
+ return result;
}
- int result = ObjectUtils.compare(requirement, other.requirement);
+ result = ObjectUtils.compare(requirement, other.requirement);
if (result != 0) {
return result;
}
return ObjectUtils.compare(capability, other.capability);
}
-}
\ No newline at end of file
+}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019 Nordix Foundation.
+ * Copyright (C) 2019-2020 Nordix Foundation.
* Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
import org.onap.policy.models.base.PfValidationResult;
/**
- * A container class for a TOSCA model with multiple service templates. This class is a container
- * class that allows a model with many service templates to be constructed that contains a well
- * formed overall TOSCA model.
+ * A container class for a TOSCA model with multiple service templates. This class is a container class that allows a
+ * model with many service templates to be constructed that contains a well formed overall TOSCA model.
*
* <p>Validation runs {@link JpaToscaModel} validation on the model and all its sub concepts.
*/
private JpaToscaServiceTemplates serviceTemplates;
/**
- * The Default Constructor creates a {@link JpaToscaModel} object with a null concept key and
- * creates an empty TOSCA model.
+ * The Default Constructor creates a {@link JpaToscaModel} object with a null concept key and creates an empty TOSCA
+ * model.
*/
public JpaToscaModel() {
this(new PfConceptKey());
}
/**
- * The Key Constructor creates a {@link JpaToscaModel} object with the given concept key and
- * creates an empty TOSCA model.
+ * The Key Constructor creates a {@link JpaToscaModel} object with the given concept key and creates an empty TOSCA
+ * model.
*
* @param key the TOSCA model key
*/
}
final JpaToscaModel other = (JpaToscaModel) otherConcept;
- if (!super.equals(other)) {
- return super.compareTo(other);
+ int result = super.compareTo(other);
+ if (result != 0) {
+ return result;
}
return serviceTemplates.compareTo(other.serviceTemplates);
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2020 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.models.tosca.simple.concepts;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import javax.persistence.CascadeType;
+import javax.persistence.Column;
+import javax.persistence.ElementCollection;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.Inheritance;
+import javax.persistence.InheritanceType;
+import javax.persistence.JoinColumn;
+import javax.persistence.JoinColumns;
+import javax.persistence.Lob;
+import javax.persistence.OneToOne;
+import javax.persistence.Table;
+import javax.ws.rs.core.Response;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import org.apache.commons.lang3.ObjectUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.onap.policy.common.utils.coder.CoderException;
+import org.onap.policy.common.utils.coder.StandardCoder;
+import org.onap.policy.models.base.PfAuthorative;
+import org.onap.policy.models.base.PfConcept;
+import org.onap.policy.models.base.PfConceptKey;
+import org.onap.policy.models.base.PfKey;
+import org.onap.policy.models.base.PfModelRuntimeException;
+import org.onap.policy.models.base.PfUtils;
+import org.onap.policy.models.base.PfValidationMessage;
+import org.onap.policy.models.base.PfValidationResult;
+import org.onap.policy.models.base.PfValidationResult.ValidationResult;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaCapabilityAssignment;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate;
+
+/**
+ * Class to represent the node template in TOSCA definition.
+ */
+@Entity
+@Table(name = "ToscaNodeTemplate")
+@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class JpaToscaNodeTemplate extends JpaToscaEntityType<ToscaNodeTemplate>
+ implements PfAuthorative<ToscaNodeTemplate> {
+ private static final long serialVersionUID = 1675770231921107988L;
+
+ private static final StandardCoder STANDARD_CODER = new StandardCoder();
+
+ @Column
+ private String type;
+
+ @ElementCollection
+ @Lob
+ private Map<String, String> properties;
+
+ // formatter:off
+ @OneToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true)
+ @JoinColumns({@JoinColumn(name = "requirementsName", referencedColumnName = "name"),
+ @JoinColumn(name = "requirementsVersion", referencedColumnName = "version")})
+ private JpaToscaRequirements requirements;
+
+ @OneToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true)
+ @JoinColumns({@JoinColumn(name = "capabilitiesName", referencedColumnName = "name"),
+ @JoinColumn(name = "capabilitiesVersion", referencedColumnName = "version")})
+ private JpaToscaCapabilityAssignments capabilities;
+ // @formatter:on
+
+ /**
+ * The Default Constructor creates a {@link JpaToscaNodeTemplate} object with a null key.
+ */
+ public JpaToscaNodeTemplate() {
+ this(new PfConceptKey());
+ }
+
+ /**
+ * The Key Constructor creates a {@link JpaToscaNodeTemplate} object with the given concept key.
+ *
+ * @param key the key
+ */
+ public JpaToscaNodeTemplate(@NonNull final PfConceptKey key) {
+ this(key, null);
+ }
+
+ /**
+ * Copy constructor.
+ *
+ * @param copyConcept the concept to copy from
+ */
+ public JpaToscaNodeTemplate(final JpaToscaNodeTemplate copyConcept) {
+ super(copyConcept);
+ this.type = copyConcept.type;
+ this.properties = PfUtils.mapMap(copyConcept.properties, String::new);
+ this.requirements =
+ (copyConcept.requirements != null ? new JpaToscaRequirements(copyConcept.requirements) : null);
+ this.capabilities =
+ (copyConcept.capabilities != null ? new JpaToscaCapabilityAssignments(copyConcept.capabilities) : null);
+ }
+
+ /**
+ * The Key Constructor creates a {@link JpaToscaParameter} object with the given concept key.
+ *
+ * @param key the key
+ * @param type the node template type
+ */
+ public JpaToscaNodeTemplate(@NonNull final PfConceptKey key, final String type) {
+ super(key);
+ this.type = type;
+ }
+
+ /**
+ * Authorative constructor.
+ *
+ * @param authorativeConcept the authorative concept to copy from
+ */
+ public JpaToscaNodeTemplate(final ToscaNodeTemplate authorativeConcept) {
+ this.fromAuthorative(authorativeConcept);
+ }
+
+ @Override
+ public ToscaNodeTemplate toAuthorative() {
+ ToscaNodeTemplate toscaNodeTemplate = new ToscaNodeTemplate();
+ super.setToscaEntity(toscaNodeTemplate);
+ super.toAuthorative();
+
+ toscaNodeTemplate.setType(type);
+
+ toscaNodeTemplate.setProperties(PfUtils.mapMap(properties, property -> {
+ try {
+ return STANDARD_CODER.decode(property, Object.class);
+ } catch (CoderException ce) {
+ String errorMessage = "error decoding property JSON value read from database: " + property;
+ throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR, errorMessage, ce);
+ }
+ }));
+
+ if (requirements != null) {
+ toscaNodeTemplate.setRequirements(requirements.toAuthorative());
+ }
+
+ if (capabilities != null) {
+ toscaNodeTemplate.setCapabilities(new LinkedHashMap<>());
+ List<Map<String, ToscaCapabilityAssignment>> capabilityAssignmentMapList = capabilities.toAuthorative();
+ for (Map<String, ToscaCapabilityAssignment> capabilityAssignmentMap : capabilityAssignmentMapList) {
+ toscaNodeTemplate.getCapabilities().putAll(capabilityAssignmentMap);
+ }
+ }
+
+ return toscaNodeTemplate;
+ }
+
+ @Override
+ public void fromAuthorative(ToscaNodeTemplate toscaNodeTemplate) {
+ super.fromAuthorative(toscaNodeTemplate);
+
+ type = toscaNodeTemplate.getType();
+
+ properties = PfUtils.mapMap(toscaNodeTemplate.getProperties(), property -> {
+ try {
+ return STANDARD_CODER.encode(property);
+ } catch (CoderException ce) {
+ String errorMessage = "error encoding property JSON value for database: " + property;
+ throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR, errorMessage, ce);
+ }
+ });
+
+ if (toscaNodeTemplate.getRequirements() != null) {
+ requirements = new JpaToscaRequirements();
+ requirements.fromAuthorative(toscaNodeTemplate.getRequirements());
+ }
+
+ if (toscaNodeTemplate.getCapabilities() != null) {
+ capabilities = new JpaToscaCapabilityAssignments();
+ capabilities.fromAuthorative(Collections.singletonList(toscaNodeTemplate.getCapabilities()));
+ }
+ }
+
+ @Override
+ public List<PfKey> getKeys() {
+ final List<PfKey> keyList = super.getKeys();
+
+ if (requirements != null) {
+ keyList.addAll(requirements.getKeys());
+ }
+
+ if (capabilities != null) {
+ keyList.addAll(capabilities.getKeys());
+ }
+
+ return keyList;
+ }
+
+ @Override
+ public void clean() {
+ super.clean();
+
+ type = type.trim();
+
+ properties = PfUtils.mapMap(properties, String::trim);
+
+ if (requirements != null) {
+ requirements.clean();
+ }
+
+ if (capabilities != null) {
+ capabilities.clean();
+ }
+ }
+
+ @Override
+ public PfValidationResult validate(final PfValidationResult resultIn) {
+ PfValidationResult result = super.validate(resultIn);
+
+ if (StringUtils.isBlank(type)) {
+ result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
+ "node template type may not be null"));
+ }
+
+ if (properties != null) {
+ result.append(validateProperties(new PfValidationResult()));
+ }
+
+ if (requirements != null) {
+ result.append(requirements.validate(result));
+ }
+
+ if (capabilities != null) {
+ result.append(validateProperties(capabilities.validate(result)));
+ }
+
+ return result;
+ }
+
+ /**
+ * Validate the properties.
+ *
+ * @param resultIn The result of validations up to now
+ * @return the validation result
+ */
+ private PfValidationResult validateProperties(final PfValidationResult resultIn) {
+ PfValidationResult result = resultIn;
+
+ for (String property : properties.values()) {
+ if (property == null) {
+ result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
+ "topology template property may not be null "));
+ }
+ }
+ return result;
+ }
+
+ @Override
+ public int compareTo(final PfConcept otherConcept) {
+ if (otherConcept == null) {
+ return -1;
+ }
+ if (this == otherConcept) {
+ return 0;
+ }
+ if (getClass() != otherConcept.getClass()) {
+ return getClass().getName().compareTo(otherConcept.getClass().getName());
+ }
+
+ final JpaToscaNodeTemplate other = (JpaToscaNodeTemplate) otherConcept;
+ int result = super.compareTo(other);
+ if (result != 0) {
+ return result;
+ }
+
+ result = type.compareTo(other.type);
+ if (result != 0) {
+ return result;
+ }
+
+ result = PfUtils.compareMaps(properties, other.properties);
+ if (result != 0) {
+ return result;
+ }
+
+ result = ObjectUtils.compare(requirements, other.requirements);
+ if (result != 0) {
+ return result;
+ }
+
+ return ObjectUtils.compare(capabilities, other.capabilities);
+ }
+}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2020 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.models.tosca.simple.concepts;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import javax.persistence.Entity;
+import javax.persistence.Inheritance;
+import javax.persistence.InheritanceType;
+import javax.persistence.Table;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import lombok.ToString;
+import org.onap.policy.models.base.PfConceptContainer;
+import org.onap.policy.models.base.PfConceptKey;
+import org.onap.policy.models.base.PfValidationResult;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate;
+import org.onap.policy.models.tosca.utils.ToscaUtils;
+
+/**
+ * This class is a container for TOSCA node templates.
+ */
+@Entity
+@Table(name = "ToscaNodeTemplates")
+@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
+@Data
+@ToString(callSuper = true)
+@EqualsAndHashCode(callSuper = true)
+public class JpaToscaNodeTemplates extends PfConceptContainer<JpaToscaNodeTemplate, ToscaNodeTemplate> {
+ public static final String DEFAULT_NAME = "ToscaNodeTemplatesSimple";
+ public static final String DEFAULT_VERSION = "1.0.0";
+ private static final long serialVersionUID = -4157979965271220098L;
+
+ /**
+ * The Default Constructor creates a {@link JpaToscaNodeTemplates} object with a null artifact key and creates an
+ * empty concept map.
+ */
+ public JpaToscaNodeTemplates() {
+ super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION));
+ }
+
+ /**
+ * The Key Constructor creates a {@link JpaToscaNodeTemplates} object with the given artifact key and creates an
+ * empty concept map.
+ *
+ * @param key the concept key
+ */
+ public JpaToscaNodeTemplates(final PfConceptKey key) {
+ super(key, new TreeMap<>());
+ }
+
+ /**
+ * This Constructor creates an concept container with all of its fields defined.
+ *
+ * @param key the concept container key
+ * @param conceptMap the concepts to be stored in the concept container
+ */
+ public JpaToscaNodeTemplates(final PfConceptKey key, final Map<PfConceptKey, JpaToscaNodeTemplate> conceptMap) {
+ super(key, conceptMap);
+ }
+
+ /**
+ * Copy constructor.
+ *
+ * @param copyConcept the concept to copy from
+ */
+ public JpaToscaNodeTemplates(final JpaToscaNodeTemplates copyConcept) {
+ super(copyConcept);
+ }
+
+ /**
+ * Authorative constructor.
+ *
+ * @param authorativeConceptMapList the authorative concept to copy from
+ */
+ public JpaToscaNodeTemplates(final List<Map<String, ToscaNodeTemplate>> authorativeConceptMapList) {
+ super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION));
+ this.fromAuthorative(authorativeConceptMapList);
+ }
+
+ @Override
+ public PfValidationResult validate(@NonNull final PfValidationResult resultIn) {
+ PfValidationResult result = super.validate(resultIn);
+
+ // Check that all ancestors of this node template exist
+ for (JpaToscaNodeTemplate nodeTemplate : this.getConceptMap().values()) {
+ ToscaUtils.getEntityTypeAncestors(this, nodeTemplate, result);
+ }
+
+ return result;
+ }
+}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2020 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.models.tosca.simple.concepts;
+
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import javax.persistence.CascadeType;
+import javax.persistence.ElementCollection;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.Inheritance;
+import javax.persistence.InheritanceType;
+import javax.persistence.JoinColumn;
+import javax.persistence.JoinColumns;
+import javax.persistence.Lob;
+import javax.persistence.OneToOne;
+import javax.persistence.Table;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.ObjectUtils;
+import org.onap.policy.models.base.PfAuthorative;
+import org.onap.policy.models.base.PfConcept;
+import org.onap.policy.models.base.PfConceptKey;
+import org.onap.policy.models.base.PfKey;
+import org.onap.policy.models.base.PfReferenceKey;
+import org.onap.policy.models.base.PfUtils;
+import org.onap.policy.models.base.PfValidationMessage;
+import org.onap.policy.models.base.PfValidationResult;
+import org.onap.policy.models.base.PfValidationResult.ValidationResult;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeType;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaProperty;
+import org.onap.policy.models.tosca.utils.ToscaUtils;
+
+/**
+ * Class to represent the node type in TOSCA definition.
+ */
+
+@Entity
+@Table(name = "ToscaNodeType")
+@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class JpaToscaNodeType extends JpaToscaEntityType<ToscaNodeType> implements PfAuthorative<ToscaNodeType> {
+ private static final long serialVersionUID = -563659852901842616L;
+
+ @ElementCollection
+ @Lob
+ private Map<String, JpaToscaProperty> properties;
+
+
+ // formatter:off
+ @OneToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true)
+ @JoinColumns({@JoinColumn(name = "requirementsName", referencedColumnName = "name"),
+ @JoinColumn(name = "requirementsVersion", referencedColumnName = "version")})
+ // @formatter:on
+ private JpaToscaRequirements requirements;
+
+ /**
+ * The Default Constructor creates a {@link JpaToscaNodeType} object with a null key.
+ */
+ public JpaToscaNodeType() {
+ this(new PfConceptKey());
+ }
+
+ /**
+ * The Key Constructor creates a {@link JpaToscaNodeType} object with the given concept key.
+ *
+ * @param key the key
+ */
+ public JpaToscaNodeType(@NonNull final PfConceptKey key) {
+ super(key);
+ }
+
+ /**
+ * Copy constructor.
+ *
+ * @param copyConcept the concept to copy from
+ */
+ public JpaToscaNodeType(final JpaToscaNodeType copyConcept) {
+ super(copyConcept);
+ this.properties = PfUtils.mapMap(copyConcept.properties, JpaToscaProperty::new);
+ this.requirements =
+ (copyConcept.requirements != null ? new JpaToscaRequirements(copyConcept.requirements) : null);
+ }
+
+ /**
+ * Authorative constructor.
+ *
+ * @param authorativeConcept the authorative concept to copy from
+ */
+ public JpaToscaNodeType(final ToscaNodeType authorativeConcept) {
+ this.fromAuthorative(authorativeConcept);
+ }
+
+ @Override
+ public ToscaNodeType toAuthorative() {
+ ToscaNodeType toscaNodeType = new ToscaNodeType();
+ super.setToscaEntity(toscaNodeType);
+ super.toAuthorative();
+
+ toscaNodeType.setProperties(PfUtils.mapMap(properties, JpaToscaProperty::toAuthorative));
+
+ if (requirements != null) {
+ toscaNodeType.setRequirements(requirements.toAuthorative());
+ }
+
+ return toscaNodeType;
+ }
+
+ @Override
+ public void fromAuthorative(final ToscaNodeType toscaNodeType) {
+ super.fromAuthorative(toscaNodeType);
+
+ // Set properties
+ if (toscaNodeType.getProperties() != null) {
+ properties = new LinkedHashMap<>();
+ for (Entry<String, ToscaProperty> toscaPropertyEntry : toscaNodeType.getProperties().entrySet()) {
+ JpaToscaProperty jpaProperty = new JpaToscaProperty(toscaPropertyEntry.getValue());
+ jpaProperty.setKey(new PfReferenceKey(getKey(), toscaPropertyEntry.getKey()));
+ properties.put(toscaPropertyEntry.getKey(), jpaProperty);
+ }
+ }
+
+ if (toscaNodeType.getRequirements() != null) {
+ requirements = new JpaToscaRequirements();
+ requirements.fromAuthorative(toscaNodeType.getRequirements());
+ }
+ }
+
+ @Override
+ public List<PfKey> getKeys() {
+ final List<PfKey> keyList = super.getKeys();
+
+ if (properties != null) {
+ for (JpaToscaProperty property : properties.values()) {
+ keyList.addAll(property.getKeys());
+ }
+ }
+
+ if (requirements != null) {
+ keyList.addAll(requirements.getKeys());
+ }
+
+ return keyList;
+ }
+
+ @Override
+ public void clean() {
+ super.clean();
+
+ if (properties != null) {
+ for (JpaToscaProperty property : properties.values()) {
+ property.clean();
+ }
+ }
+
+ if (requirements != null) {
+ requirements.clean();
+ }
+ }
+
+ @Override
+ public PfValidationResult validate(@NonNull final PfValidationResult resultIn) {
+ PfValidationResult result = super.validate(resultIn);
+
+ if (PfKey.NULL_KEY_VERSION.equals(getKey().getVersion())) {
+ result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
+ "key version is a null version"));
+ }
+
+ if (properties != null) {
+ result = validateProperties(result);
+ }
+
+ if (requirements != null) {
+ result = requirements.validate(result);
+ }
+
+ return result;
+ }
+
+ /**
+ * Validate the capabiltiy type properties.
+ *
+ * @param resultIn The result of validations up to now
+ * @return the validation result
+ */
+ private PfValidationResult validateProperties(final PfValidationResult resultIn) {
+ PfValidationResult result = resultIn;
+
+ for (JpaToscaProperty property : properties.values()) {
+ if (property == null) {
+ result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
+ "node type property may not be null "));
+ } else {
+ result = property.validate(result);
+ }
+ }
+ return result;
+ }
+
+ @Override
+ public int compareTo(final PfConcept otherConcept) {
+ if (otherConcept == null) {
+ return -1;
+ }
+ if (this == otherConcept) {
+ return 0;
+ }
+ if (getClass() != otherConcept.getClass()) {
+ return getClass().getName().compareTo(otherConcept.getClass().getName());
+ }
+
+ final JpaToscaNodeType other = (JpaToscaNodeType) otherConcept;
+ int result = super.compareTo(other);
+ if (result != 0) {
+ return result;
+ }
+
+ result = PfUtils.compareMaps(properties, other.properties);
+ if (result != 0) {
+ return result;
+ }
+
+ return ObjectUtils.compare(requirements, other.requirements);
+ }
+
+ /**
+ * Get the data types referenced in a node type.
+ *
+ * @return the data types referenced in a node type
+ */
+ public Collection<PfConceptKey> getReferencedDataTypes() {
+ if (properties == null) {
+ return CollectionUtils.emptyCollection();
+ }
+
+ Set<PfConceptKey> referencedDataTypes = new LinkedHashSet<>();
+
+ for (JpaToscaProperty property : properties.values()) {
+ referencedDataTypes.add(property.getType());
+
+ if (property.getEntrySchema() != null) {
+ referencedDataTypes.add(property.getEntrySchema().getType());
+ }
+ }
+
+ referencedDataTypes.removeAll(ToscaUtils.getPredefinedDataTypes());
+
+ return referencedDataTypes;
+ }
+}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2020 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.models.tosca.simple.concepts;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import javax.persistence.Entity;
+import javax.persistence.Inheritance;
+import javax.persistence.InheritanceType;
+import javax.persistence.Table;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import lombok.ToString;
+import org.onap.policy.models.base.PfConceptContainer;
+import org.onap.policy.models.base.PfConceptKey;
+import org.onap.policy.models.base.PfValidationResult;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeType;
+import org.onap.policy.models.tosca.utils.ToscaUtils;
+
+/**
+ * This class is a container for TOSCA node types.
+ */
+@Entity
+@Table(name = "ToscaNodeTypes")
+@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
+@Data
+@ToString(callSuper = true)
+@EqualsAndHashCode(callSuper = true)
+public class JpaToscaNodeTypes extends PfConceptContainer<JpaToscaNodeType, ToscaNodeType> {
+ public static final String DEFAULT_NAME = "ToscaNodeTypesSimple";
+ public static final String DEFAULT_VERSION = "1.0.0";
+ private static final long serialVersionUID = -4157979965271220098L;
+
+ /**
+ * The Default Constructor creates a {@link JpaToscaNodeTypes} object with a null artifact key and creates an
+ * empty concept map.
+ */
+ public JpaToscaNodeTypes() {
+ super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION));
+ }
+
+ /**
+ * The Key Constructor creates a {@link JpaToscaNodeTypes} object with the given artifact key and creates an
+ * empty concept map.
+ *
+ * @param key the concept key
+ */
+ public JpaToscaNodeTypes(final PfConceptKey key) {
+ super(key, new TreeMap<>());
+ }
+
+ /**
+ * This Constructor creates an concept container with all of its fields defined.
+ *
+ * @param key the concept container key
+ * @param conceptMap the concepts to be stored in the concept container
+ */
+ public JpaToscaNodeTypes(final PfConceptKey key, final Map<PfConceptKey, JpaToscaNodeType> conceptMap) {
+ super(key, conceptMap);
+ }
+
+ /**
+ * Copy constructor.
+ *
+ * @param copyConcept the concept to copy from
+ */
+ public JpaToscaNodeTypes(final JpaToscaNodeTypes copyConcept) {
+ super(copyConcept);
+ }
+
+ /**
+ * Authorative constructor.
+ *
+ * @param authorativeConceptMapList the authorative concept to copy from
+ */
+ public JpaToscaNodeTypes(final List<Map<String, ToscaNodeType>> authorativeConceptMapList) {
+ super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION));
+ this.fromAuthorative(authorativeConceptMapList);
+ }
+
+ @Override
+ public PfValidationResult validate(@NonNull final PfValidationResult resultIn) {
+ PfValidationResult result = super.validate(resultIn);
+
+ // Check that all ancestors of this policy type exist
+ for (JpaToscaNodeType nodeType : this.getConceptMap().values()) {
+ ToscaUtils.getEntityTypeAncestors(this, nodeType, result);
+ }
+
+ return result;
+ }
+}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2020 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.models.tosca.simple.concepts;
+
+import java.util.List;
+import javax.persistence.Column;
+import javax.persistence.EmbeddedId;
+import javax.persistence.Entity;
+import javax.persistence.Inheritance;
+import javax.persistence.InheritanceType;
+import javax.persistence.Table;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import org.apache.commons.lang3.StringUtils;
+import org.onap.policy.common.utils.coder.YamlJsonTranslator;
+import org.onap.policy.models.base.PfAuthorative;
+import org.onap.policy.models.base.PfConcept;
+import org.onap.policy.models.base.PfConceptKey;
+import org.onap.policy.models.base.PfKey;
+import org.onap.policy.models.base.PfReferenceKey;
+import org.onap.policy.models.base.PfValidationMessage;
+import org.onap.policy.models.base.PfValidationResult;
+import org.onap.policy.models.base.PfValidationResult.ValidationResult;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaParameter;
+
+/**
+ * Class to represent the parameter in TOSCA definition.
+ */
+@Entity
+@Table(name = "ToscaParameter")
+@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class JpaToscaParameter extends PfConcept implements PfAuthorative<ToscaParameter> {
+ private static final long serialVersionUID = 1675770231921107988L;
+
+ @EmbeddedId
+ private PfReferenceKey key;
+
+ @Column
+ private PfConceptKey type;
+
+ @Column
+ private String value;
+
+ /**
+ * The Default Constructor creates a {@link JpaToscaParameter} object with a null key.
+ */
+ public JpaToscaParameter() {
+ this(new PfReferenceKey());
+ }
+
+ /**
+ * The Key Constructor creates a {@link JpaToscaParameter} object with the given concept key.
+ *
+ * @param key the key
+ */
+ public JpaToscaParameter(@NonNull final PfReferenceKey key) {
+ this(key, new PfConceptKey());
+ }
+
+ /**
+ * The Key Constructor creates a {@link JpaToscaParameter} object with the given concept key.
+ *
+ * @param key the key
+ * @param type the key of the parameter type
+ */
+ public JpaToscaParameter(@NonNull final PfReferenceKey key, @NonNull final PfConceptKey type) {
+ this.key = key;
+ this.type = type;
+ }
+
+ /**
+ * Copy constructor.
+ *
+ * @param copyConcept the concept to copy from
+ */
+ public JpaToscaParameter(final JpaToscaParameter copyConcept) {
+ super(copyConcept);
+ this.key = new PfReferenceKey(copyConcept.key);
+ this.type = new PfConceptKey(copyConcept.type);
+ this.value = copyConcept.value;
+ }
+
+ /**
+ * Authorative constructor.
+ *
+ * @param authorativeConcept the authorative concept to copy from
+ */
+ public JpaToscaParameter(final ToscaParameter authorativeConcept) {
+ this.fromAuthorative(authorativeConcept);
+ }
+
+ @Override
+ public ToscaParameter toAuthorative() {
+ ToscaParameter toscaParameter = new ToscaParameter();
+
+ toscaParameter.setName(key.getLocalName());
+
+ toscaParameter.setType(type.getName());
+ toscaParameter.setTypeVersion(type.getVersion());
+
+ if (!StringUtils.isBlank(value)) {
+ toscaParameter.setValue(new YamlJsonTranslator().fromYaml(value, Object.class));
+ }
+
+ return toscaParameter;
+ }
+
+ @Override
+ public void fromAuthorative(ToscaParameter toscaParameter) {
+ this.setKey(new PfReferenceKey());
+ getKey().setLocalName(toscaParameter.getName());
+
+ if (toscaParameter.getTypeVersion() != null) {
+ type = new PfConceptKey(toscaParameter.getType(), toscaParameter.getTypeVersion());
+ } else {
+ type = new PfConceptKey(toscaParameter.getType(), PfKey.NULL_KEY_VERSION);
+ }
+
+ value = new YamlJsonTranslator().toYaml(toscaParameter.getValue());
+ }
+
+ @Override
+ public List<PfKey> getKeys() {
+ final List<PfKey> keyList = getKey().getKeys();
+
+ keyList.addAll(type.getKeys());
+
+ return keyList;
+ }
+
+ @Override
+ public void clean() {
+ key.clean();
+
+ type.clean();
+
+ if (value != null) {
+ value = value.trim();
+ }
+ }
+
+ @Override
+ public PfValidationResult validate(final PfValidationResult resultIn) {
+ PfValidationResult result = resultIn;
+
+ if (key.isNullKey()) {
+ result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
+ "paremeter key is a null key"));
+ }
+
+ result = key.validate(result);
+
+ if (type == null || type.isNullKey()) {
+ result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
+ "parameter type may not be null"));
+ }
+
+ return result;
+ }
+
+ @Override
+ public int compareTo(final PfConcept otherConcept) {
+ if (otherConcept == null) {
+ return -1;
+ }
+ if (this == otherConcept) {
+ return 0;
+ }
+ if (getClass() != otherConcept.getClass()) {
+ return getClass().getName().compareTo(otherConcept.getClass().getName());
+ }
+
+ final JpaToscaParameter other = (JpaToscaParameter) otherConcept;
+ int result = key.compareTo(other.key);
+ if (result != 0) {
+ return result;
+ }
+
+ return value.compareTo(other.value);
+ }
+}
package org.onap.policy.models.tosca.simple.concepts;
-import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
private static final String METADATA_POLICY_ID_TAG = "policy-id";
private static final String METADATA_POLICY_VERSION_TAG = "policy-version";
+ private static final StandardCoder STANDARD_CODER = new StandardCoder();
+
// @formatter:off
@Column
@AttributeOverrides({
@ElementCollection
@Lob
- private Map<String, String> properties = new LinkedHashMap<>();
+ private Map<String, String> properties;
@ElementCollection
- private List<PfConceptKey> targets = new ArrayList<>();
+ private List<PfConceptKey> targets;
// @formatter:on
/**
toscaPolicy.setTypeVersion(null);
}
- if (properties != null) {
- Map<String, Object> propertyMap = new LinkedHashMap<>();
-
- final StandardCoder coder = new StandardCoder();
-
- for (Entry<String, String> entry : properties.entrySet()) {
- try {
- // TODO: This is a HACK, we need to validate the properties against their
- // TODO: their data type in their policy type definition in TOSCA, which means reading
- // TODO: the policy type from the database and parsing the property value object correctly
- // TODO: Here we are simply reading a JSON string from the database and deserializing the
- // TODO: property value from JSON
- propertyMap.put(entry.getKey(), coder.decode(entry.getValue(), Object.class));
- } catch (CoderException ce) {
- String errorMessage = "error decoding property JSON value read from database: key=" + entry.getKey()
- + ", value=" + entry.getValue();
- throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR, errorMessage, ce);
- }
+ toscaPolicy.setProperties(PfUtils.mapMap(properties, property -> {
+ try {
+ return STANDARD_CODER.decode(property, Object.class);
+ } catch (CoderException ce) {
+ String errorMessage = "error decoding property JSON value read from database: " + property;
+ throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR, errorMessage, ce);
}
-
- toscaPolicy.setProperties(propertyMap);
- }
+ }));
return toscaPolicy;
}
type.setName(toscaPolicy.getType());
} else {
throw new PfModelRuntimeException(Response.Status.BAD_REQUEST,
- "PolicyType type not specified, the type of the PolicyType for this policy must be specified in "
- + "the type field");
+ "PolicyType type not specified, the type of the PolicyType for this policy must be specified in "
+ + "the type field");
}
if (toscaPolicy.getTypeVersion() != null) {
type.setVersion(toscaPolicy.getTypeVersion());
} else {
throw new PfModelRuntimeException(Response.Status.BAD_REQUEST,
- "PolicyType version not specified, the version of the PolicyType for this policy must be specified in "
- + "the type_version field");
+ "PolicyType version not specified, the version of the PolicyType for this policy must be specified"
+ + " in the type_version field");
}
- if (toscaPolicy.getProperties() != null) {
- properties = new LinkedHashMap<>();
-
- final StandardCoder coder = new StandardCoder();
-
- for (Entry<String, Object> propertyEntry : toscaPolicy.getProperties().entrySet()) {
- // TODO: This is a HACK, we need to validate the properties against their
- // TODO: their data type in their policy type definition in TOSCA, which means reading
- // TODO: the policy type from the database and parsing the property value object correctly
- // TODO: Here we are simply serializing the property value into a string and storing it
- // TODO: unvalidated into the database
- try {
- properties.put(propertyEntry.getKey(), coder.encode(propertyEntry.getValue()));
- } catch (CoderException ce) {
- String errorMessage = "error encoding property JSON value for database: key="
- + propertyEntry.getKey() + ", value=" + propertyEntry.getValue();
- throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR, errorMessage, ce);
- }
+ properties = PfUtils.mapMap(toscaPolicy.getProperties(), property -> {
+ try {
+ return STANDARD_CODER.encode(property);
+ } catch (CoderException ce) {
+ String errorMessage = "error encoding property JSON value for database: " + property;
+ throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR, errorMessage, ce);
}
- }
+ });
// Add the property metadata if it doesn't exist already
if (toscaPolicy.getMetadata() == null) {
if (PfKey.NULL_KEY_VERSION.equals(getKey().getVersion())) {
result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
- "key version is a null version"));
+ "key version is a null version"));
}
if (type == null || type.isNullKey()) {
result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
- "type is null or a null key"));
+ "type is null or a null key"));
} else {
result = type.validate(result);
}
for (Entry<String, String> propertyEntry : properties.entrySet()) {
if (!ParameterValidationUtils.validateStringParameter(propertyEntry.getKey())) {
result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
- "policy property key may not be null "));
+ "policy property key may not be null "));
} else if (propertyEntry.getValue() == null) {
result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
- "policy property value may not be null "));
+ "policy property value may not be null "));
}
}
}
/**
* Validate the policy targets.
*
- * @param result The result of validations up to now
+ * @param resultIn The result of validations up to now
* @return the validation result
*/
private PfValidationResult validateTargets(final PfValidationResult resultIn) {
for (PfConceptKey target : targets) {
if (target == null) {
result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
- "policy target may not be null "));
+ "policy target may not be null "));
} else {
result = target.validate(result);
}
}
final JpaToscaPolicy other = (JpaToscaPolicy) otherConcept;
- if (!super.equals(other)) {
- return super.compareTo(other);
+ int result = super.compareTo(other);
+ if (result != 0) {
+ return result;
}
- if (!type.equals(other.type)) {
- return type.compareTo(other.type);
+ result = type.compareTo(other.type);
+ if (result != 0) {
+ return result;
}
- int retVal = PfUtils.compareObjects(properties, other.properties);
- if (retVal != 0) {
- return retVal;
+ result = PfUtils.compareMaps(properties, other.properties);
+ if (result != 0) {
+ return result;
}
- return PfUtils.compareObjects(targets, other.targets);
+ return PfUtils.compareCollections(targets, other.targets);
}
}
package org.onap.policy.models.tosca.simple.concepts;
-import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
@ElementCollection
@Lob
- private Map<String, JpaToscaProperty> properties = new LinkedHashMap<>();
+ private Map<String, JpaToscaProperty> properties;
@ElementCollection
- private List<PfConceptKey> targets = new ArrayList<>();
+ private List<PfConceptKey> targets;
@ElementCollection
- private List<JpaToscaTrigger> triggers = new ArrayList<>();
+ private List<JpaToscaTrigger> triggers;
/**
* The Default Constructor creates a {@link JpaToscaPolicyType} object with a null key.
super.setToscaEntity(toscaPolicyType);
super.toAuthorative();
- if (properties != null) {
- Map<String, ToscaProperty> propertyMap = new LinkedHashMap<>();
-
- for (Entry<String, JpaToscaProperty> entry : properties.entrySet()) {
- propertyMap.put(entry.getKey(), entry.getValue().toAuthorative());
- }
-
- toscaPolicyType.setProperties(propertyMap);
- }
+ toscaPolicyType.setProperties(PfUtils.mapMap(properties, JpaToscaProperty::toAuthorative));
return toscaPolicyType;
}
}
final JpaToscaPolicyType other = (JpaToscaPolicyType) otherConcept;
- if (!super.equals(other)) {
- return super.compareTo(other);
+ int result = super.compareTo(other);
+ if (result != 0) {
+ return result;
}
- int retVal = PfUtils.compareObjects(properties, other.properties);
- if (retVal != 0) {
- return retVal;
+ result = PfUtils.compareMaps(properties, other.properties);
+ if (result != 0) {
+ return result;
}
- retVal = PfUtils.compareObjects(targets, other.targets);
- if (retVal != 0) {
- return retVal;
+ result = PfUtils.compareCollections(targets, other.targets);
+ if (result != 0) {
+ return result;
}
- return PfUtils.compareObjects(triggers, other.triggers);
+ return PfUtils.compareCollections(triggers, other.triggers);
}
/**
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
-import java.util.Map.Entry;
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.EmbeddedId;
import org.onap.policy.models.base.PfValidationMessage;
import org.onap.policy.models.base.PfValidationResult;
import org.onap.policy.models.base.PfValidationResult.ValidationResult;
-import org.onap.policy.models.tosca.authorative.concepts.ToscaConstraint;
import org.onap.policy.models.tosca.authorative.concepts.ToscaProperty;
import org.onap.policy.models.tosca.authorative.concepts.ToscaProperty.Status;
private Status status = Status.SUPPORTED;
@ElementCollection
- private List<JpaToscaConstraint> constraints = new ArrayList<>();
+ private List<JpaToscaConstraint> constraints;
@Column
- private JpaToscaEntrySchema entrySchema;
+ private JpaToscaSchemaDefinition entrySchema;
@ElementCollection
- private Map<String, String> metadata = new LinkedHashMap<>();
+ private Map<String, String> metadata;
/**
* The Default Constructor creates a {@link JpaToscaProperty} object with a null key.
/**
* The Key Constructor creates a {@link JpaToscaProperty} object with the given concept key.
*
- * @param key the key
+ * @param key the key
* @param type the key of the property type
*/
public JpaToscaProperty(@NonNull final PfReferenceKey key, @NonNull final PfConceptKey type) {
this.status = copyConcept.status;
// Constraints are immutable
this.constraints = (copyConcept.constraints != null ? new ArrayList<>(copyConcept.constraints) : null);
- this.entrySchema = (copyConcept.entrySchema != null ? new JpaToscaEntrySchema(copyConcept.entrySchema) : null);
+ this.entrySchema =
+ (copyConcept.entrySchema != null ? new JpaToscaSchemaDefinition(copyConcept.entrySchema) : null);
this.metadata = (copyConcept.metadata != null ? new LinkedHashMap<>(copyConcept.metadata) : null);
}
toscaProperty.setDefaultValue(new YamlJsonTranslator().fromYaml(defaultValue, Object.class));
}
- if (constraints != null) {
- List<ToscaConstraint> toscaConstraints = new ArrayList<>();
-
- for (JpaToscaConstraint constraint : constraints) {
- toscaConstraints.add(constraint.toAuthorative());
- }
-
- toscaProperty.setConstraints(toscaConstraints);
- }
+ toscaProperty.setConstraints(PfUtils.mapList(constraints, JpaToscaConstraint::toAuthorative));
if (entrySchema != null) {
toscaProperty.setEntrySchema(entrySchema.toAuthorative());
}
- if (metadata != null) {
- toscaProperty.setMetadata(new LinkedHashMap<>(metadata));
- }
+ toscaProperty.setMetadata(PfUtils.mapMap(metadata, metadataItem -> metadataItem));
return toscaProperty;
}
defaultValue = null;
}
- if (toscaProperty.getConstraints() != null) {
- constraints = new ArrayList<>();
-
- for (ToscaConstraint toscaConstraint : toscaProperty.getConstraints()) {
- constraints.add(JpaToscaConstraint.newInstance(toscaConstraint));
- }
- }
+ constraints = PfUtils.mapList(toscaProperty.getConstraints(), JpaToscaConstraint::newInstance);
if (toscaProperty.getEntrySchema() != null) {
- entrySchema = new JpaToscaEntrySchema(toscaProperty.getEntrySchema());
- }
-
- // Add the property metadata if it doesn't exist already
- if (toscaProperty.getMetadata() != null) {
- metadata = new LinkedHashMap<>(toscaProperty.getMetadata());
+ entrySchema = new JpaToscaSchemaDefinition(toscaProperty.getEntrySchema());
}
+ metadata = PfUtils.mapMap(toscaProperty.getMetadata(), metadataItem -> metadataItem);
}
@Override
entrySchema.clean();
}
- if (metadata != null) {
- for (Entry<String, String> metadataEntry : metadata.entrySet()) {
- metadataEntry.setValue(metadataEntry.getValue().trim());
- }
- }
+ metadata = PfUtils.mapMap(metadata, String::trim);
}
@Override
if (key.isNullKey()) {
result.addValidationMessage(
- new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, "key is a null key"));
+ new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, "key is a null key"));
}
result = key.validate(result);
if (type == null || type.isNullKey()) {
result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "property type may not be null"));
+ "property type may not be null"));
}
return validateFields(result);
if (description != null && description.trim().length() == 0) {
result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "property description may not be blank"));
+ "property description may not be blank"));
}
if (defaultValue != null && defaultValue.trim().length() == 0) {
result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "property default value may not be null"));
+ "property default value may not be null"));
}
if (constraints != null) {
for (JpaToscaConstraint constraint : constraints) {
if (constraint == null) {
result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "property constraint may not be null "));
+ "property constraint may not be null "));
}
}
}
return result;
}
- result = PfUtils.compareObjects(constraints, other.constraints);
+ result = PfUtils.compareCollections(constraints, other.constraints);
+ if (result != 0) {
+ return result;
+ }
+
+ result = entrySchema.compareTo(other.entrySchema);
if (result != 0) {
return result;
}
- return entrySchema.compareTo(other.entrySchema);
+ return PfUtils.compareMaps(metadata, other.metadata);
}
}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2020 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.models.tosca.simple.concepts;
+
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import javax.persistence.ElementCollection;
+import javax.persistence.Entity;
+import javax.persistence.Inheritance;
+import javax.persistence.InheritanceType;
+import javax.persistence.Lob;
+import javax.persistence.Table;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import org.apache.commons.collections4.CollectionUtils;
+import org.onap.policy.models.base.PfAuthorative;
+import org.onap.policy.models.base.PfConcept;
+import org.onap.policy.models.base.PfConceptKey;
+import org.onap.policy.models.base.PfKey;
+import org.onap.policy.models.base.PfReferenceKey;
+import org.onap.policy.models.base.PfUtils;
+import org.onap.policy.models.base.PfValidationMessage;
+import org.onap.policy.models.base.PfValidationResult;
+import org.onap.policy.models.base.PfValidationResult.ValidationResult;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaProperty;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaRelationshipType;
+import org.onap.policy.models.tosca.utils.ToscaUtils;
+
+/**
+ * Class to represent the relationship type in TOSCA definition.
+ */
+
+@Entity
+@Table(name = "ToscaRelationshipType")
+@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class JpaToscaRelationshipType extends JpaToscaEntityType<ToscaRelationshipType>
+ implements PfAuthorative<ToscaRelationshipType> {
+ private static final long serialVersionUID = -563659852901842616L;
+
+ @ElementCollection
+ @Lob
+ private Map<String, JpaToscaProperty> properties;
+
+ /**
+ * The Default Constructor creates a {@link JpaToscaRelationshipType} object with a null key.
+ */
+ public JpaToscaRelationshipType() {
+ this(new PfConceptKey());
+ }
+
+ /**
+ * The Key Constructor creates a {@link JpaToscaRelationshipType} object with the given concept key.
+ *
+ * @param key the key
+ */
+ public JpaToscaRelationshipType(@NonNull final PfConceptKey key) {
+ super(key);
+ }
+
+ /**
+ * Copy constructor.
+ *
+ * @param copyConcept the concept to copy from
+ */
+ public JpaToscaRelationshipType(final JpaToscaRelationshipType copyConcept) {
+ super(copyConcept);
+ this.properties = PfUtils.mapMap(copyConcept.properties, JpaToscaProperty::new);
+ }
+
+ /**
+ * Authorative constructor.
+ *
+ * @param authorativeConcept the authorative concept to copy from
+ */
+ public JpaToscaRelationshipType(final ToscaRelationshipType authorativeConcept) {
+ this.fromAuthorative(authorativeConcept);
+ }
+
+ @Override
+ public ToscaRelationshipType toAuthorative() {
+ ToscaRelationshipType toscaRelationshipType = new ToscaRelationshipType();
+ super.setToscaEntity(toscaRelationshipType);
+ super.toAuthorative();
+
+ toscaRelationshipType.setProperties(PfUtils.mapMap(properties, JpaToscaProperty::toAuthorative));
+
+ return toscaRelationshipType;
+ }
+
+ @Override
+ public void fromAuthorative(final ToscaRelationshipType toscaRelationshipType) {
+ super.fromAuthorative(toscaRelationshipType);
+
+ // Set properties
+ if (toscaRelationshipType.getProperties() != null) {
+ properties = new LinkedHashMap<>();
+ for (Entry<String, ToscaProperty> toscaPropertyEntry : toscaRelationshipType.getProperties().entrySet()) {
+ JpaToscaProperty jpaProperty = new JpaToscaProperty(toscaPropertyEntry.getValue());
+ jpaProperty.setKey(new PfReferenceKey(getKey(), toscaPropertyEntry.getKey()));
+ properties.put(toscaPropertyEntry.getKey(), jpaProperty);
+ }
+ }
+ }
+
+ @Override
+ public List<PfKey> getKeys() {
+ final List<PfKey> keyList = super.getKeys();
+
+ if (properties != null) {
+ for (JpaToscaProperty property : properties.values()) {
+ keyList.addAll(property.getKeys());
+ }
+ }
+
+ return keyList;
+ }
+
+ @Override
+ public void clean() {
+ super.clean();
+
+ if (properties != null) {
+ for (JpaToscaProperty property : properties.values()) {
+ property.clean();
+ }
+ }
+ }
+
+ @Override
+ public PfValidationResult validate(@NonNull final PfValidationResult resultIn) {
+ PfValidationResult result = super.validate(resultIn);
+
+ if (PfKey.NULL_KEY_VERSION.equals(getKey().getVersion())) {
+ result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
+ "key version is a null version"));
+ }
+
+ if (properties != null) {
+ result = validateProperties(result);
+ }
+
+ return result;
+ }
+
+ /**
+ * Validate the capabiltiy type properties.
+ *
+ * @param resultIn The result of validations up to now
+ * @return the validation result
+ */
+ private PfValidationResult validateProperties(final PfValidationResult resultIn) {
+ PfValidationResult result = resultIn;
+
+ for (JpaToscaProperty property : properties.values()) {
+ if (property == null) {
+ result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
+ "relationship type property may not be null "));
+ } else {
+ result = property.validate(result);
+ }
+ }
+ return result;
+ }
+
+ @Override
+ public int compareTo(final PfConcept otherConcept) {
+ if (otherConcept == null) {
+ return -1;
+ }
+ if (this == otherConcept) {
+ return 0;
+ }
+ if (getClass() != otherConcept.getClass()) {
+ return getClass().getName().compareTo(otherConcept.getClass().getName());
+ }
+
+ final JpaToscaRelationshipType other = (JpaToscaRelationshipType) otherConcept;
+ int result = super.compareTo(other);
+ if (result != 0) {
+ return result;
+ }
+
+ return PfUtils.compareMaps(properties, other.properties);
+ }
+
+ /**
+ * Get the data types referenced in a relationship type.
+ *
+ * @return the data types referenced in a relationship type
+ */
+ public Collection<PfConceptKey> getReferencedDataTypes() {
+ if (properties == null) {
+ return CollectionUtils.emptyCollection();
+ }
+
+ Set<PfConceptKey> referencedDataTypes = new LinkedHashSet<>();
+
+ for (JpaToscaProperty property : properties.values()) {
+ referencedDataTypes.add(property.getType());
+
+ if (property.getEntrySchema() != null) {
+ referencedDataTypes.add(property.getEntrySchema().getType());
+ }
+ }
+
+ referencedDataTypes.removeAll(ToscaUtils.getPredefinedDataTypes());
+
+ return referencedDataTypes;
+ }
+}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2020 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.models.tosca.simple.concepts;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import javax.persistence.Entity;
+import javax.persistence.Inheritance;
+import javax.persistence.InheritanceType;
+import javax.persistence.Table;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import lombok.ToString;
+import org.onap.policy.models.base.PfConceptContainer;
+import org.onap.policy.models.base.PfConceptKey;
+import org.onap.policy.models.base.PfValidationResult;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaRelationshipType;
+import org.onap.policy.models.tosca.utils.ToscaUtils;
+
+/**
+ * This class is a container for TOSCA relationship types.
+ */
+@Entity
+@Table(name = "ToscaRelationshipTypes")
+@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
+@Data
+@ToString(callSuper = true)
+@EqualsAndHashCode(callSuper = true)
+public class JpaToscaRelationshipTypes extends PfConceptContainer<JpaToscaRelationshipType, ToscaRelationshipType> {
+ public static final String DEFAULT_NAME = "ToscaRelationshipTypesSimple";
+ public static final String DEFAULT_VERSION = "1.0.0";
+ private static final long serialVersionUID = -4157979965271220098L;
+
+ /**
+ * The Default Constructor creates a {@link JpaToscaRelationshipTypes} object with a null artifact key and creates
+ * an empty concept map.
+ */
+ public JpaToscaRelationshipTypes() {
+ super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION));
+ }
+
+ /**
+ * The Key Constructor creates a {@link JpaToscaRelationshipTypes} object with the given artifact key and creates an
+ * empty concept map.
+ *
+ * @param key the concept key
+ */
+ public JpaToscaRelationshipTypes(final PfConceptKey key) {
+ super(key, new TreeMap<>());
+ }
+
+ /**
+ * This Constructor creates an concept container with all of its fields defined.
+ *
+ * @param key the concept container key
+ * @param conceptMap the concepts to be stored in the concept container
+ */
+ public JpaToscaRelationshipTypes(final PfConceptKey key,
+ final Map<PfConceptKey, JpaToscaRelationshipType> conceptMap) {
+ super(key, conceptMap);
+ }
+
+ /**
+ * Copy constructor.
+ *
+ * @param copyConcept the concept to copy from
+ */
+ public JpaToscaRelationshipTypes(final JpaToscaRelationshipTypes copyConcept) {
+ super(copyConcept);
+ }
+
+ /**
+ * Authorative constructor.
+ *
+ * @param authorativeConceptMapList the authorative concept to copy from
+ */
+ public JpaToscaRelationshipTypes(final List<Map<String, ToscaRelationshipType>> authorativeConceptMapList) {
+ super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION));
+ this.fromAuthorative(authorativeConceptMapList);
+ }
+
+ @Override
+ public PfValidationResult validate(@NonNull final PfValidationResult resultIn) {
+ PfValidationResult result = super.validate(resultIn);
+
+ // Check that all ancestors of this policy type exist
+ for (JpaToscaRelationshipType relationshipType : this.getConceptMap().values()) {
+ ToscaUtils.getEntityTypeAncestors(this, relationshipType, result);
+ }
+
+ return result;
+ }
+}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP Requirement Model
+ * ================================================================================
+ * Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2019-2020 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.models.tosca.simple.concepts;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import javax.persistence.Column;
+import javax.persistence.ElementCollection;
+import javax.persistence.Entity;
+import javax.persistence.Inheritance;
+import javax.persistence.InheritanceType;
+import javax.persistence.Lob;
+import javax.persistence.Table;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import org.onap.policy.common.utils.coder.YamlJsonTranslator;
+import org.onap.policy.models.base.PfAuthorative;
+import org.onap.policy.models.base.PfConcept;
+import org.onap.policy.models.base.PfConceptKey;
+import org.onap.policy.models.base.PfKey;
+import org.onap.policy.models.base.PfUtils;
+import org.onap.policy.models.base.PfValidationMessage;
+import org.onap.policy.models.base.PfValidationResult;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaRequirement;
+
+/**
+ * Class to represent the requirement in TOSCA definition.
+ *
+ * @author Chenfei Gao (cgao@research.att.com)
+ * @author Liam Fallon (liam.fallon@est.tech)
+ */
+@Entity
+@Table(name = "ToscaRequirement")
+@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class JpaToscaRequirement extends JpaToscaEntityType<ToscaRequirement>
+ implements PfAuthorative<ToscaRequirement> {
+
+ private static final long serialVersionUID = 2785481541573683089L;
+ private static final String AUTHORATIVE_UNBOUNDED_LITERAL = "UNBOUNDED";
+ private static final Double JPA_UNBOUNDED_VALUE = -1.0;
+
+ @Column
+ private String capability;
+
+ @Column
+ private String node;
+
+ @Column
+ private String relationship;
+
+ @ElementCollection
+ private List<Double> occurrences;
+
+ @ElementCollection
+ @Lob
+ private Map<String, String> properties;
+
+ /**
+ * The Default Constructor creates a {@link JpaToscaRequirement} object with a null key.
+ */
+ public JpaToscaRequirement() {
+ this(new PfConceptKey());
+ }
+
+ /**
+ * The Key Constructor creates a {@link JpaToscaRequirement} object with the given concept key.
+ *
+ * @param key the key
+ */
+ public JpaToscaRequirement(@NonNull final PfConceptKey key) {
+ super(key);
+ }
+
+ /**
+ * Copy constructor.
+ *
+ * @param copyConcept the concept to copy from
+ */
+ public JpaToscaRequirement(@NonNull final JpaToscaRequirement copyConcept) {
+ super(copyConcept);
+ this.capability = copyConcept.capability;
+ this.node = copyConcept.node;
+ this.relationship = copyConcept.relationship;
+ this.occurrences = new ArrayList<>(copyConcept.occurrences);
+ this.properties = PfUtils.mapMap(copyConcept.properties, String::new);
+ }
+
+ /**
+ * Authorative constructor.
+ *
+ * @param authorativeConcept the authorative concept to copy from
+ */
+ public JpaToscaRequirement(final ToscaRequirement authorativeConcept) {
+ super(new PfConceptKey());
+ this.fromAuthorative(authorativeConcept);
+ }
+
+ @Override
+ public ToscaRequirement toAuthorative() {
+ ToscaRequirement toscaRequirement = new ToscaRequirement();
+ super.setToscaEntity(toscaRequirement);
+ super.toAuthorative();
+
+ toscaRequirement.setCapability(capability);
+ toscaRequirement.setNode(node);
+ toscaRequirement.setRelationship(relationship);
+
+ if (occurrences != null) {
+ List<Object> occurrencesList = new ArrayList<>(occurrences);
+ for (Double occurrence : occurrences) {
+ if (occurrence == JPA_UNBOUNDED_VALUE) {
+ occurrencesList.add(AUTHORATIVE_UNBOUNDED_LITERAL);
+ } else {
+ occurrencesList.add(occurrence.doubleValue());
+ }
+ }
+ toscaRequirement.setOccurrences(occurrencesList);
+ }
+
+ if (properties != null) {
+ Map<String, Object> propertiesMap = new LinkedHashMap<>();
+
+ for (Map.Entry<String, String> entry : properties.entrySet()) {
+ propertiesMap.put(entry.getKey(), new YamlJsonTranslator().fromYaml(entry.getValue(), Object.class));
+ }
+
+ toscaRequirement.setProperties(propertiesMap);
+ }
+
+ return toscaRequirement;
+ }
+
+ @Override
+ public void fromAuthorative(@NonNull final ToscaRequirement toscaRequirement) {
+ super.fromAuthorative(toscaRequirement);
+
+ capability = toscaRequirement.getCapability();
+ node = toscaRequirement.getNode();
+ relationship = toscaRequirement.getRelationship();
+
+ if (toscaRequirement.getOccurrences() != null) {
+ occurrences = new ArrayList<>();
+ for (Object occurrence : toscaRequirement.getOccurrences()) {
+ if (occurrence.equals(AUTHORATIVE_UNBOUNDED_LITERAL)) {
+ occurrences.add(JPA_UNBOUNDED_VALUE);
+ } else {
+ occurrences.add((Double) occurrence);
+ }
+ }
+ }
+
+ if (toscaRequirement.getProperties() != null) {
+ properties = new LinkedHashMap<>();
+ for (Map.Entry<String, Object> toscaPropertyEntry : toscaRequirement.getProperties().entrySet()) {
+ String jpaProperty = new YamlJsonTranslator().toYaml(toscaPropertyEntry.getValue());
+ properties.put(toscaPropertyEntry.getKey(), jpaProperty);
+ }
+ }
+
+ }
+
+ @Override
+ public List<PfKey> getKeys() {
+ return super.getKeys();
+ }
+
+ @Override
+ public void clean() {
+ super.clean();
+
+ capability = capability.trim();
+ node = node.trim();
+ relationship = relationship.trim();
+
+ properties = PfUtils.mapMap(properties, String::trim);
+ }
+
+ @Override
+ public PfValidationResult validate(@NonNull final PfValidationResult resultIn) {
+ PfValidationResult result = super.validate(resultIn);
+
+ if (properties != null) {
+ result = validateProperties(result);
+ }
+
+ if (occurrences != null) {
+ result = validateOccurrences(result);
+ }
+
+ return result;
+ }
+
+ /**
+ * Validate the properties.
+ *
+ * @param resultIn The result of validations up to now
+ * @return the validation result
+ */
+ private PfValidationResult validateProperties(final PfValidationResult resultIn) {
+ PfValidationResult result = resultIn;
+
+ for (String property : properties.values()) {
+ if (property == null) {
+ result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(),
+ PfValidationResult.ValidationResult.INVALID, "topology template property may not be null "));
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Validate the occurrences.
+ *
+ * @param resultIn The result of validations up to now
+ * @return the validation result
+ */
+ private PfValidationResult validateOccurrences(final PfValidationResult resultIn) {
+ PfValidationResult result = resultIn;
+
+ for (Double occurrence : occurrences) {
+ if (occurrence == null) {
+ result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(),
+ PfValidationResult.ValidationResult.INVALID, "requirement occurrence value may not be null "));
+ }
+ if (occurrence < -1.0) {
+ result.addValidationMessage(
+ new PfValidationMessage(getKey(), this.getClass(), PfValidationResult.ValidationResult.INVALID,
+ "requirement occurrence value may not be negative"));
+ }
+ }
+
+ return result;
+ }
+
+ @Override
+ public int compareTo(final PfConcept otherConcept) {
+ if (otherConcept == null) {
+ return -1;
+ }
+
+ if (this == otherConcept) {
+ return 0;
+ }
+
+ if (getClass() != otherConcept.getClass()) {
+ return getClass().getName().compareTo(otherConcept.getClass().getName());
+ }
+
+ final JpaToscaRequirement other = (JpaToscaRequirement) otherConcept;
+ int result = super.compareTo(other);
+ if (result != 0) {
+ return result;
+ }
+
+ result = capability.compareTo(other.capability);
+ if (result != 0) {
+ return result;
+ }
+
+ result = node.compareTo(other.node);
+ if (result != 0) {
+ return result;
+ }
+
+ result = relationship.compareTo(other.relationship);
+ if (result != 0) {
+ return result;
+ }
+
+ result = PfUtils.compareCollections(occurrences, other.occurrences);
+ if (result != 0) {
+ return result;
+ }
+
+ return PfUtils.compareMaps(properties, other.properties);
+ }
+}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2020 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.models.tosca.simple.concepts;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import javax.persistence.Entity;
+import javax.persistence.Inheritance;
+import javax.persistence.InheritanceType;
+import javax.persistence.Table;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import lombok.ToString;
+import org.onap.policy.models.base.PfAuthorative;
+import org.onap.policy.models.base.PfConceptContainer;
+import org.onap.policy.models.base.PfConceptKey;
+import org.onap.policy.models.base.PfValidationResult;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaRequirement;
+import org.onap.policy.models.tosca.utils.ToscaUtils;
+
+/**
+ * This class is a container for TOSCA requirements.
+ *
+ * @author Liam Fallon (liam.fallon@est.tech)
+ */
+@Entity
+@Table(name = "ToscaRequirements")
+@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
+@Data
+@ToString(callSuper = true)
+@EqualsAndHashCode(callSuper = true)
+public class JpaToscaRequirements extends PfConceptContainer<JpaToscaRequirement, ToscaRequirement>
+ implements PfAuthorative<List<Map<String, ToscaRequirement>>> {
+ private static final long serialVersionUID = -7526648702327776101L;
+
+ public static final String DEFAULT_NAME = "ToscaRequirementsSimple";
+ public static final String DEFAULT_VERSION = "1.0.0";
+
+ /**
+ * The Default Constructor creates a {@link JpaToscaRequirements} object with a null artifact key and creates an
+ * empty concept map.
+ */
+ public JpaToscaRequirements() {
+ super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION));
+ }
+
+ /**
+ * The Key Constructor creates a {@link JpaToscaRequirements} object with the given artifact key and creates an
+ * empty concept map.
+ *
+ * @param key the concept key
+ */
+ public JpaToscaRequirements(final PfConceptKey key) {
+ super(key, new TreeMap<>());
+ }
+
+ /**
+ * This Constructor creates an concept container with all of its fields defined.
+ *
+ * @param key the concept container key
+ * @param conceptMap the concepts to be stored in the concept container
+ */
+ public JpaToscaRequirements(final PfConceptKey key, final Map<PfConceptKey, JpaToscaRequirement> conceptMap) {
+ super(key, conceptMap);
+ }
+
+ /**
+ * Copy constructor.
+ *
+ * @param copyConcept the concept to copy from
+ */
+ public JpaToscaRequirements(final JpaToscaRequirements copyConcept) {
+ super(copyConcept);
+ }
+
+ /**
+ * Authorative constructor.
+ *
+ * @param authorativeConceptMapList the authorative concept to copy from
+ */
+ public JpaToscaRequirements(final List<Map<String, ToscaRequirement>> authorativeConceptMapList) {
+ super(new PfConceptKey(DEFAULT_NAME, DEFAULT_VERSION));
+ this.fromAuthorative(authorativeConceptMapList);
+ }
+
+ @Override
+ public PfValidationResult validate(@NonNull final PfValidationResult resultIn) {
+ PfValidationResult result = super.validate(resultIn);
+
+ for (JpaToscaRequirement requirement : this.getConceptMap().values()) {
+ ToscaUtils.getEntityTypeAncestors(this, requirement, result);
+ }
+
+ return result;
+ }
+}
@Data
@EqualsAndHashCode(callSuper = false)
@NoArgsConstructor
-public class JpaToscaEntrySchema
- implements PfAuthorative<ToscaSchemaDefinition>, Serializable, Comparable<JpaToscaEntrySchema> {
+public class JpaToscaSchemaDefinition
+ implements PfAuthorative<ToscaSchemaDefinition>, Serializable, Comparable<JpaToscaSchemaDefinition> {
private static final long serialVersionUID = 3645882081163287058L;
private String description;
@ElementCollection
- private List<JpaToscaConstraint> constraints = new ArrayList<>();
+ private List<JpaToscaConstraint> constraints;
/**
- * The full constructor creates a {@link JpaToscaEntrySchema} object with mandatory fields.
+ * The full constructor creates a {@link JpaToscaSchemaDefinition} object with mandatory fields.
*
* @param type the type of the entry schema
*/
- public JpaToscaEntrySchema(@NonNull final PfConceptKey type) {
+ public JpaToscaSchemaDefinition(@NonNull final PfConceptKey type) {
this.type = type;
}
*
* @param copyConcept the concept to copy from
*/
- public JpaToscaEntrySchema(@NonNull final JpaToscaEntrySchema copyConcept) {
+ public JpaToscaSchemaDefinition(@NonNull final JpaToscaSchemaDefinition copyConcept) {
copyConcept.copyTo(this);
}
*
* @param authorativeConcept the authorative concept to copy from
*/
- public JpaToscaEntrySchema(final ToscaSchemaDefinition authorativeConcept) {
+ public JpaToscaSchemaDefinition(final ToscaSchemaDefinition authorativeConcept) {
this.fromAuthorative(authorativeConcept);
}
}
@Override
- public int compareTo(final JpaToscaEntrySchema other) {
+ public int compareTo(final JpaToscaSchemaDefinition other) {
if (other == null) {
return -1;
}
return result;
}
- return PfUtils.compareObjects(constraints, other.constraints);
+ return PfUtils.compareCollections(constraints, other.constraints);
}
/**
* @param target the other schemaa
* @return the copied concept
*/
- public JpaToscaEntrySchema copyTo(@NonNull final JpaToscaEntrySchema target) {
- Assertions.instanceOf(target, JpaToscaEntrySchema.class);
+ public JpaToscaSchemaDefinition copyTo(@NonNull final JpaToscaSchemaDefinition target) {
+ Assertions.instanceOf(target, JpaToscaSchemaDefinition.class);
- final JpaToscaEntrySchema copy = (target);
+ final JpaToscaSchemaDefinition copy = (target);
copy.setType(new PfConceptKey(type));
copy.setDescription(description);
import org.onap.policy.models.base.PfValidationMessage;
import org.onap.policy.models.base.PfValidationResult;
import org.onap.policy.models.base.PfValidationResult.ValidationResult;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaCapabilityType;
import org.onap.policy.models.tosca.authorative.concepts.ToscaDataType;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeType;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaRelationshipType;
import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
/**
@SerializedName("data_types")
private JpaToscaDataTypes dataTypes;
+ @OneToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true)
+ @JoinColumns(
+ {
+ @JoinColumn(name = "capabilityTypesName", referencedColumnName = "name"),
+ @JoinColumn(name = "capabilityTypesVersion", referencedColumnName = "version")
+ }
+ )
+ @SerializedName("capability_types")
+ private JpaToscaCapabilityTypes capabilityTypes;
+
+ @OneToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true)
+ @JoinColumns(
+ {
+ @JoinColumn(name = "relationshipTypesName", referencedColumnName = "name"),
+ @JoinColumn(name = "relationshipTypesVersion", referencedColumnName = "version")
+ }
+ )
+ @SerializedName("relationship_types")
+ private JpaToscaRelationshipTypes relationshipTypes;
+
+ @OneToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true)
+ @JoinColumns(
+ {
+ @JoinColumn(name = "nodeTypesName", referencedColumnName = "name"),
+ @JoinColumn(name = "nodeTypesVersion", referencedColumnName = "version")
+ }
+ )
+ @SerializedName("node_types")
+ private JpaToscaNodeTypes nodeTypes;
+
@OneToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true)
@JoinColumns(
{
super(copyConcept);
this.toscaDefinitionsVersion = copyConcept.toscaDefinitionsVersion;
this.dataTypes = (copyConcept.dataTypes != null ? new JpaToscaDataTypes(copyConcept.dataTypes) : null);
+ this.capabilityTypes =
+ (copyConcept.capabilityTypes != null ? new JpaToscaCapabilityTypes(copyConcept.capabilityTypes) : null);
+ this.relationshipTypes =
+ (copyConcept.relationshipTypes != null ? new JpaToscaRelationshipTypes(copyConcept.relationshipTypes)
+ : null);
+ this.nodeTypes = (copyConcept.nodeTypes != null ? new JpaToscaNodeTypes(copyConcept.nodeTypes) : null);
this.policyTypes = (copyConcept.policyTypes != null ? new JpaToscaPolicyTypes(copyConcept.policyTypes) : null);
this.topologyTemplate =
(copyConcept.topologyTemplate != null ? new JpaToscaTopologyTemplate(copyConcept.topologyTemplate)
}
}
+ if (capabilityTypes != null) {
+ toscaServiceTemplate.setCapabilityTypes(new LinkedHashMap<>());
+ List<Map<String, ToscaCapabilityType>> capabilityTypeMapList = capabilityTypes.toAuthorative();
+ for (Map<String, ToscaCapabilityType> capabilityTypeMap : capabilityTypeMapList) {
+ toscaServiceTemplate.getCapabilityTypes().putAll(capabilityTypeMap);
+ }
+ }
+
+ if (relationshipTypes != null) {
+ toscaServiceTemplate.setRelationshipTypes(new LinkedHashMap<>());
+ List<Map<String, ToscaRelationshipType>> relationshipTypeMapList = relationshipTypes.toAuthorative();
+ for (Map<String, ToscaRelationshipType> relationshipTypeMap : relationshipTypeMapList) {
+ toscaServiceTemplate.getRelationshipTypes().putAll(relationshipTypeMap);
+ }
+ }
+
+ if (nodeTypes != null) {
+ toscaServiceTemplate.setNodeTypes(new LinkedHashMap<>());
+ List<Map<String, ToscaNodeType>> nodeTypeMapList = nodeTypes.toAuthorative();
+ for (Map<String, ToscaNodeType> nodeTypeMap : nodeTypeMapList) {
+ toscaServiceTemplate.getNodeTypes().putAll(nodeTypeMap);
+ }
+ }
+
if (policyTypes != null) {
toscaServiceTemplate.setPolicyTypes(new LinkedHashMap<>());
List<Map<String, ToscaPolicyType>> policyTypeMapList = policyTypes.toAuthorative();
dataTypes.fromAuthorative(Collections.singletonList(toscaServiceTemplate.getDataTypes()));
}
+ if (toscaServiceTemplate.getCapabilityTypes() != null) {
+ capabilityTypes = new JpaToscaCapabilityTypes();
+ capabilityTypes.fromAuthorative(Collections.singletonList(toscaServiceTemplate.getCapabilityTypes()));
+ }
+
+ if (toscaServiceTemplate.getRelationshipTypes() != null) {
+ relationshipTypes = new JpaToscaRelationshipTypes();
+ relationshipTypes.fromAuthorative(Collections.singletonList(toscaServiceTemplate.getRelationshipTypes()));
+ }
+
+ if (toscaServiceTemplate.getNodeTypes() != null) {
+ nodeTypes = new JpaToscaNodeTypes();
+ nodeTypes.fromAuthorative(Collections.singletonList(toscaServiceTemplate.getNodeTypes()));
+ }
+
if (toscaServiceTemplate.getPolicyTypes() != null) {
policyTypes = new JpaToscaPolicyTypes();
policyTypes.fromAuthorative(Collections.singletonList(toscaServiceTemplate.getPolicyTypes()));
keyList.addAll(dataTypes.getKeys());
}
+ if (capabilityTypes != null) {
+ keyList.addAll(capabilityTypes.getKeys());
+ }
+
+ if (relationshipTypes != null) {
+ keyList.addAll(relationshipTypes.getKeys());
+ }
+
+ if (nodeTypes != null) {
+ keyList.addAll(nodeTypes.getKeys());
+ }
+
if (policyTypes != null) {
keyList.addAll(policyTypes.getKeys());
}
dataTypes.clean();
}
+ if (capabilityTypes != null) {
+ capabilityTypes.clean();
+ }
+
+ if (relationshipTypes != null) {
+ relationshipTypes.clean();
+ }
+
+ if (nodeTypes != null) {
+ nodeTypes.clean();
+ }
+
if (policyTypes != null) {
policyTypes.clean();
}
result = dataTypes.validate(result);
}
+ if (capabilityTypes != null) {
+ result = capabilityTypes.validate(result);
+ }
+
+ if (relationshipTypes != null) {
+ result = relationshipTypes.validate(result);
+ }
+
+ if (nodeTypes != null) {
+ result = nodeTypes.validate(result);
+ }
+
if (policyTypes != null) {
result = policyTypes.validate(result);
}
return result;
}
+ result = ObjectUtils.compare(capabilityTypes, other.capabilityTypes);
+ if (result != 0) {
+ return result;
+ }
+
+ result = ObjectUtils.compare(relationshipTypes, other.relationshipTypes);
+ if (result != 0) {
+ return result;
+ }
+
+ result = ObjectUtils.compare(nodeTypes, other.nodeTypes);
+ if (result != 0) {
+ return result;
+ }
+
result = ObjectUtils.compare(policyTypes, other.policyTypes);
if (result != 0) {
return result;
* ONAP Policy Model
* ================================================================================
* Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2019 Nordix Foundation.
+ * Modifications Copyright (C) 2019-2020 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
}
final JpaToscaTimeInterval other = (JpaToscaTimeInterval) otherConcept;
- if (!key.equals(other.key)) {
- return key.compareTo(other.key);
+ int result = key.compareTo(other.key);
+ if (result != 0) {
+ return result;
}
- int returnVal = PfUtils.compareObjects(startTime, other.startTime);
- if (returnVal != 0) {
- return returnVal;
+ result = PfUtils.compareObjects(startTime, other.startTime);
+ if (result != 0) {
+ return result;
}
return PfUtils.compareObjects(endTime, other.endTime);
package org.onap.policy.models.tosca.simple.concepts;
+import com.google.gson.annotations.SerializedName;
+import java.util.Collections;
+import java.util.LinkedHashMap;
import java.util.List;
+import java.util.Map;
import javax.persistence.CascadeType;
import javax.persistence.Column;
+import javax.persistence.ElementCollection;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.InheritanceType;
import javax.persistence.JoinColumn;
import javax.persistence.JoinColumns;
+import javax.persistence.Lob;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import lombok.Data;
import org.onap.policy.models.base.PfConcept;
import org.onap.policy.models.base.PfKey;
import org.onap.policy.models.base.PfReferenceKey;
+import org.onap.policy.models.base.PfUtils;
import org.onap.policy.models.base.PfValidationMessage;
import org.onap.policy.models.base.PfValidationResult;
import org.onap.policy.models.base.PfValidationResult.ValidationResult;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaParameter;
import org.onap.policy.models.tosca.authorative.concepts.ToscaTopologyTemplate;
/**
private String description;
// @formatter:off
+ @ElementCollection
+ @Lob
+ private Map<String, JpaToscaParameter> inputs;
+
+ @OneToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true)
+ @JoinColumns(
+ {
+ @JoinColumn(name = "nodeTemplatesName", referencedColumnName = "name"),
+ @JoinColumn(name = "nodeTemplatessVersion", referencedColumnName = "version")
+ }
+ )
+ @SerializedName("data_types")
+ private JpaToscaNodeTemplates nodeTemplates;
+
@OneToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true)
@JoinColumns(
{
super(copyConcept);
this.key = new PfReferenceKey(copyConcept.key);
this.description = copyConcept.description;
+ this.inputs = PfUtils.mapMap(copyConcept.inputs, JpaToscaParameter::new);
+ this.nodeTemplates =
+ (copyConcept.nodeTemplates != null ? new JpaToscaNodeTemplates(copyConcept.nodeTemplates) : null);
this.policies = (copyConcept.policies != null ? new JpaToscaPolicies(copyConcept.policies) : null);
}
toscaTopologyTemplate.setDescription(description);
+ if (inputs != null) {
+ Map<String, ToscaParameter> inputMap = new LinkedHashMap<>();
+
+ for (Map.Entry<String, JpaToscaParameter> entry : inputs.entrySet()) {
+ inputMap.put(entry.getKey(), entry.getValue().toAuthorative());
+ }
+
+ toscaTopologyTemplate.setInputs(inputMap);
+ }
+
+ if (nodeTemplates != null) {
+ toscaTopologyTemplate.setNodeTemplates(new LinkedHashMap<>());
+ List<Map<String, ToscaNodeTemplate>> nodeTemplateMapList = nodeTemplates.toAuthorative();
+ for (Map<String, ToscaNodeTemplate> nodeTemplateMap : nodeTemplateMapList) {
+ toscaTopologyTemplate.getNodeTemplates().putAll(nodeTemplateMap);
+ }
+ }
+
if (policies != null) {
toscaTopologyTemplate.setPolicies(policies.toAuthorative());
}
public void fromAuthorative(ToscaTopologyTemplate toscaTopologyTemplate) {
description = toscaTopologyTemplate.getDescription();
+ if (toscaTopologyTemplate.getInputs() != null) {
+ inputs = new LinkedHashMap<>();
+ for (Map.Entry<String, ToscaParameter> toscaInputEntry : toscaTopologyTemplate.getInputs().entrySet()) {
+ JpaToscaParameter jpaInput = new JpaToscaParameter(toscaInputEntry.getValue());
+ jpaInput.setKey(new PfReferenceKey(getKey(), toscaInputEntry.getKey()));
+ inputs.put(toscaInputEntry.getKey(), jpaInput);
+ }
+ }
+
+ if (toscaTopologyTemplate.getNodeTemplates() != null) {
+ nodeTemplates = new JpaToscaNodeTemplates();
+ nodeTemplates.fromAuthorative(Collections.singletonList(toscaTopologyTemplate.getNodeTemplates()));
+ }
+
if (toscaTopologyTemplate.getPolicies() != null) {
policies = new JpaToscaPolicies();
policies.fromAuthorative(toscaTopologyTemplate.getPolicies());
public List<PfKey> getKeys() {
final List<PfKey> keyList = getKey().getKeys();
+ if (inputs != null) {
+ for (JpaToscaParameter input : inputs.values()) {
+ keyList.addAll(input.getKeys());
+ }
+ }
+
+ if (nodeTemplates != null) {
+ keyList.addAll(nodeTemplates.getKeys());
+ }
+
if (policies != null) {
keyList.addAll(policies.getKeys());
}
description = (description != null ? description.trim() : null);
+ if (inputs != null) {
+ for (JpaToscaParameter input : inputs.values()) {
+ input.clean();
+ }
+ }
+
+ if (nodeTemplates != null) {
+ nodeTemplates.clean();
+ }
+
if (policies != null) {
policies.clean();
}
"property description may not be blank"));
}
+ if (inputs != null) {
+ result = validateInputs(result);
+ }
+
+
+ if (nodeTemplates != null) {
+ result = nodeTemplates.validate(result);
+ }
+
if (policies != null) {
result = policies.validate(result);
}
return result;
}
+ /**
+ * Validate the inputs.
+ *
+ * @param resultIn The result of validations up to now
+ * @return the validation result
+ */
+ private PfValidationResult validateInputs(final PfValidationResult resultIn) {
+ PfValidationResult result = resultIn;
+
+ for (JpaToscaParameter input : inputs.values()) {
+ if (input == null) {
+ result.addValidationMessage(new PfValidationMessage(getKey(), this.getClass(), ValidationResult.INVALID,
+ "topology template input may not be null "));
+ } else {
+ result = input.validate(result);
+ }
+ }
+ return result;
+ }
+
@Override
public int compareTo(final PfConcept otherConcept) {
int result = compareToWithoutEntities(otherConcept);
return result;
}
- return ObjectUtils.compare(policies, ((JpaToscaTopologyTemplate) otherConcept).policies);
+ final JpaToscaTopologyTemplate other = (JpaToscaTopologyTemplate) otherConcept;
+
+ result = PfUtils.compareObjects(inputs, other.inputs);
+ if (result != 0) {
+ return result;
+ }
+
+ result = ObjectUtils.compare(nodeTemplates, other.nodeTemplates);
+ if (result != 0) {
+ return result;
+ }
+
+ return ObjectUtils.compare(policies, other.policies);
}
/**
- * Compare this topology template to another topology template, ignoring contained entitites.
+ * Compare this topology template to another topology template, ignoring contained entities.
*
* @param otherConcept the other topology template
* @return the result of the comparison
* ONAP Policy Model
* ================================================================================
* Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2019 Nordix Foundation.
+ * Modifications Copyright (C) 2019-2020 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
this.eventType = copyConcept.eventType;
this.schedule = (copyConcept.schedule != null ? new JpaToscaTimeInterval(copyConcept.schedule) : null);
this.targetFilter =
- (copyConcept.targetFilter != null ? new JpaToscaEventFilter(copyConcept.targetFilter) : null);
+ (copyConcept.targetFilter != null ? new JpaToscaEventFilter(copyConcept.targetFilter) : null);
this.condition = copyConcept.condition;
this.constraint = copyConcept.constraint;
this.period = copyConcept.period;
}
final JpaToscaTrigger other = (JpaToscaTrigger) otherConcept;
- if (!key.equals(other.key)) {
- return key.compareTo(other.key);
+ int result = key.compareTo(other.key);
+ if (result != 0) {
+ return result;
}
return compareFields(other);
}
/**
- * Compare the fields of this ToscaTrigger object with the fields of the other ToscaProperty
- * object.
+ * Compare the fields of this ToscaTrigger object with the fields of the other ToscaProperty object.
*
* @param other the other ToscaTrigger object
*/
for (Entry<PfConceptKey, ? extends JpaToscaEntityType<? extends ToscaEntity>> fragmentEntry : fragmentContainer
.getConceptMap().entrySet()) {
- JpaToscaEntityType<? extends ToscaEntity> containerEntry =
+ JpaToscaEntityType<? extends ToscaEntity> containerEntity =
compositeContainer.getConceptMap().get(fragmentEntry.getKey());
- if (containerEntry != null && !containerEntry.equals(fragmentEntry.getValue())) {
+ if (containerEntity != null && containerEntity.compareTo(fragmentEntry.getValue()) != 0) {
result.addValidationMessage(new PfValidationMessage(fragmentEntry.getKey(),
ToscaServiceTemplateUtils.class,
ValidationResult.INVALID, "entity in incoming fragment does not equal existing entity"));
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2020 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.models.tosca.simple.concepts;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.Test;
+import org.onap.policy.models.base.PfConceptKey;
+import org.onap.policy.models.base.PfValidationResult;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaCapabilityAssignment;
+
+/**
+ * DAO test for JpaToscaCapabilityAssignment.
+ */
+public class JpaToscaCapabilityAssignmentTest {
+
+ private static final String KEY_IS_NULL = "key is marked .*on.*ull but is null";
+
+ @Test
+ public void testPropertyPojo() {
+ assertNotNull(new JpaToscaCapabilityAssignment());
+ assertNotNull(new JpaToscaCapabilityAssignment(new PfConceptKey()));
+ assertNotNull(new JpaToscaCapabilityAssignment(new JpaToscaCapabilityAssignment()));
+ assertNotNull(new JpaToscaCapabilityAssignment(new ToscaCapabilityAssignment()));
+
+ assertThatThrownBy(() -> new JpaToscaCapabilityAssignment((PfConceptKey) null)).hasMessageMatching(KEY_IS_NULL);
+ assertThatThrownBy(() -> new JpaToscaCapabilityAssignment((JpaToscaCapabilityAssignment) null))
+ .hasMessageMatching("copyConcept is marked .*on.*ull but is null");
+ assertThatThrownBy(() -> new JpaToscaCapabilityAssignment((ToscaCapabilityAssignment) null))
+ .hasMessageMatching("authorativeConcept is marked .*on.*ull but is null");
+
+ PfConceptKey caKey = new PfConceptKey("tParentKey", "0.0.1");
+
+ JpaToscaCapabilityAssignment caNull = new JpaToscaCapabilityAssignment(caKey);
+ caNull.setProperties(null);
+ caNull.setAttributes(null);
+ caNull.setOccurrences(null);
+
+ assertEquals(caNull, new JpaToscaCapabilityAssignment(caNull));
+
+ JpaToscaCapabilityAssignment ca = new JpaToscaCapabilityAssignment(caKey);
+
+ assertEquals(ca, new JpaToscaCapabilityAssignment(ca));
+ assertEquals(caKey, ca.getKeys().get(0));
+
+ ca.clean();
+ ca.validate(new PfValidationResult());
+ assertThat(ca.getProperties()).isNullOrEmpty();
+ assertThat(ca.getAttributes()).isNullOrEmpty();
+
+ ca.setProperties(null);
+ ca.setAttributes(null);
+ ca.setOccurrences(null);
+ ca.clean();
+ ca.validate(new PfValidationResult());
+ assertEquals(null, ca.getProperties());
+ assertEquals(null, ca.getAttributes());
+
+ Map<String, String> properties = new LinkedHashMap<>();
+ properties.put("Key0", " Untrimmed Value ");
+ ca.setProperties(properties);
+
+ Map<String, String> attributes = new LinkedHashMap<>();
+ attributes.put("Key0", " Untrimmed Value ");
+ ca.setAttributes(attributes);
+
+ List<Integer> occurrences = new ArrayList<>();
+ occurrences.add(12345);
+ ca.setOccurrences(occurrences);
+
+ ca.clean();
+ ca.validate(new PfValidationResult());
+ assertEquals("Untrimmed Value", ca.getProperties().get("Key0"));
+ assertEquals("Untrimmed Value", ca.getAttributes().get("Key0"));
+
+ ca.getProperties().put("Key1", null);
+ ca.getAttributes().put("Key1", null);
+ ca.getOccurrences().add(null);
+ ca.getOccurrences().add(-12345);
+ PfValidationResult result = ca.validate(new PfValidationResult());
+ assertThat(result.toString()).contains("capability assignment property Key1 value may not be null");
+ assertThat(result.toString()).contains("capability assignment attribute Key1 value may not be null");
+ assertThat(result.toString()).contains("capability assignment occurrence value may not be negative");
+ }
+
+ @Test
+ public void testCompareTo() {
+ assertEquals(-1, new JpaToscaCapabilityAssignment().compareTo(null));
+ assertEquals(0, new JpaToscaCapabilityAssignment().compareTo(new JpaToscaCapabilityAssignment()));
+
+ JpaToscaCapabilityAssignment ca = new JpaToscaCapabilityAssignment();
+ assertEquals(0, ca.compareTo(ca));
+ assertEquals(18, ca.compareTo(new PfConceptKey()));
+
+ JpaToscaCapabilityAssignment ca2 = new JpaToscaCapabilityAssignment();
+ ca2.getKey().setName("ca2");
+ assertEquals(-21, ca.compareTo(ca2));
+
+ ca.getKey().setName("ca");
+ ca2.getKey().setName("ca");
+
+ ca.setProperties(new LinkedHashMap<>());
+ ca2.setProperties(new LinkedHashMap<>());
+ ca.getProperties().put("Key0", "Value0");
+ assertEquals(-1737938642, ca.compareTo(ca2));
+ ca2.getProperties().put("Key0", "Value0");
+ assertEquals(0, ca.compareTo(ca2));
+
+ ca.setAttributes(new LinkedHashMap<>());
+ ca2.setAttributes(new LinkedHashMap<>());
+ ca.getAttributes().put("Key0", "Value0");
+ assertEquals(-1737938642, ca.compareTo(ca2));
+ ca2.getAttributes().put("Key0", "Value0");
+ assertEquals(0, ca.compareTo(ca2));
+
+ ca.setOccurrences(new ArrayList<>());
+ ca2.setOccurrences(new ArrayList<>());
+ ca.getOccurrences().add(12345);
+ assertEquals(12375, ca.compareTo(ca2));
+ ca2.getOccurrences().add(12345);
+ assertEquals(0, ca.compareTo(ca2));
+ }
+
+ @Test
+ public void testAuthorative() {
+ ToscaCapabilityAssignment tca =
+ new JpaToscaCapabilityAssignment(new ToscaCapabilityAssignment()).toAuthorative();
+
+ JpaToscaCapabilityAssignment jtca = new JpaToscaCapabilityAssignment(tca);
+ ToscaCapabilityAssignment tca2 = jtca.toAuthorative();
+ assertEquals(tca, tca2);
+ }
+}
JpaToscaProperty prop3 = new JpaToscaProperty(new PfReferenceKey(dt0.getKey(), "prop4"));
prop3.setType(new PfConceptKey("the.property.Type1", "0.0.1"));
- prop3.setEntrySchema(new JpaToscaEntrySchema());
+ prop3.setEntrySchema(new JpaToscaSchemaDefinition());
prop3.getEntrySchema().setType(new PfConceptKey("the.property.Type3", "0.0.1"));
assertTrue(prop3.validate(new PfValidationResult()).isValid());
JpaToscaProperty prop4 = new JpaToscaProperty(new PfReferenceKey(dt0.getKey(), "prop4"));
prop4.setType(new PfConceptKey("the.property.Type1", "0.0.1"));
- prop4.setEntrySchema(new JpaToscaEntrySchema());
+ prop4.setEntrySchema(new JpaToscaSchemaDefinition());
prop4.getEntrySchema().setType(new PfConceptKey("the.property.Type2", "0.0.1"));
assertTrue(prop4.validate(new PfValidationResult()).isValid());
import java.util.ArrayList;
import java.util.HashMap;
+import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import org.onap.policy.models.base.PfConceptKey;
import org.onap.policy.models.base.PfKey;
+import org.onap.policy.models.base.PfUtils;
import org.onap.policy.models.base.PfValidationResult;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
assertThatThrownBy(() -> {
new JpaToscaPolicy(pol);
}).hasMessage(
- "PolicyType version not specified, the version of the PolicyType for this policy must be specified in the "
- + "type_version field");
+ "PolicyType version not specified, the version of the PolicyType for this policy must be specified in"
+ + " the type_version field");
assertThatThrownBy(() -> {
new JpaToscaPolicy((PfConceptKey) null);
tp.fromAuthorative(pol1);
assertEquals("2.2.3", tp.getType().getVersion());
}
+
+ @Test
+ public void testPolicyProperties() {
+
+ Map<String, Object> properties = new LinkedHashMap<>();
+
+ // @formatter:off
+ properties.put("byte", Byte.valueOf("2"));
+ properties.put("short", Short.valueOf("1234"));
+ properties.put("int", Integer.valueOf("12345678"));
+ properties.put("long", Long.valueOf("1234567890"));
+ properties.put("float", Float.valueOf("12345.678"));
+ properties.put("double", Double.valueOf("-12345.6789"));
+ properties.put("char", '%');
+ properties.put("string", "hello");
+ properties.put("boolean", false);
+ // @formatter:on
+
+ ToscaPolicy tp = new ToscaPolicy();
+ tp.setType("org.onap.Policy");
+ tp.setTypeVersion("1.2.3");
+ tp.setProperties(properties);
+
+ JpaToscaPolicy jtp = new JpaToscaPolicy(tp);
+ assertEquals(0, PfUtils.compareCollections(tp.getProperties().keySet(), jtp.getProperties().keySet()));
+
+ ToscaPolicy tpFromTo = jtp.toAuthorative();
+
+ // @formatter:off
+ assertEquals(2, tpFromTo.getProperties().get("byte"));
+ assertEquals(1234, tpFromTo.getProperties().get("short"));
+ assertEquals(12345678, tpFromTo.getProperties().get("int"));
+ assertEquals(1234567890, tpFromTo.getProperties().get("long"));
+ assertEquals(12345.678, tpFromTo.getProperties().get("float"));
+ assertEquals(-12345.6789, tpFromTo.getProperties().get("double"));
+ assertEquals("%", tpFromTo.getProperties().get("char"));
+ assertEquals("hello", tpFromTo.getProperties().get("string"));
+ assertEquals(false, tpFromTo.getProperties().get("boolean"));
+ // @formatter:on
+ }
}
JpaToscaProperty prop3 = new JpaToscaProperty(new PfReferenceKey(pt0.getKey(), "prop4"));
prop3.setType(new PfConceptKey("the.property.Type1", "0.0.1"));
- prop3.setEntrySchema(new JpaToscaEntrySchema());
+ prop3.setEntrySchema(new JpaToscaSchemaDefinition());
prop3.getEntrySchema().setType(new PfConceptKey("the.property.Type3", "0.0.1"));
assertTrue(prop3.validate(new PfValidationResult()).isValid());
JpaToscaProperty prop4 = new JpaToscaProperty(new PfReferenceKey(pt0.getKey(), "prop4"));
prop4.setType(new PfConceptKey("the.property.Type1", "0.0.1"));
- prop4.setEntrySchema(new JpaToscaEntrySchema());
+ prop4.setEntrySchema(new JpaToscaSchemaDefinition());
prop4.getEntrySchema().setType(new PfConceptKey("the.property.Type2", "0.0.1"));
assertTrue(prop4.validate(new PfValidationResult()).isValid());
assertEquals(constraints, tp.getConstraints());
PfConceptKey typeKey = new PfConceptKey("type", VERSION_001);
- JpaToscaEntrySchema tes = new JpaToscaEntrySchema(typeKey);
+ JpaToscaSchemaDefinition tes = new JpaToscaSchemaDefinition(typeKey);
tp.setEntrySchema(tes);
TreeMap<String, String> metadata = new TreeMap<>();
otherDt.setConstraints(constraints);
assertNotEquals(0, tp.compareTo(otherDt));
otherDt.setEntrySchema(tes);
+ assertNotEquals(0, tp.compareTo(otherDt));
+ otherDt.setMetadata(metadata);
assertEquals(0, tp.compareTo(otherDt));
otherDt.setRequired(true);
tp.setConstraints(constraints);
PfConceptKey typeKey = new PfConceptKey("type", VERSION_001);
- JpaToscaEntrySchema tes = new JpaToscaEntrySchema(typeKey);
+ JpaToscaSchemaDefinition tes = new JpaToscaSchemaDefinition(typeKey);
tp.setEntrySchema(tes);
TreeMap<String, String> metadata = new TreeMap<>();
*
* @author Liam Fallon (liam.fallon@est.tech)
*/
-public class JpaToscaEntrySchemaTest {
+public class JpaToscaSchemaDefinitionTest {
private static final String A_DESCRIPTION = "A Description";
@Test
public void testEntrySchemaPojo() {
- assertNotNull(new JpaToscaEntrySchema(new PfConceptKey()));
- assertNotNull(new JpaToscaEntrySchema(new JpaToscaEntrySchema(new PfConceptKey())));
+ assertNotNull(new JpaToscaSchemaDefinition(new PfConceptKey()));
+ assertNotNull(new JpaToscaSchemaDefinition(new JpaToscaSchemaDefinition(new PfConceptKey())));
- assertThatThrownBy(() -> new JpaToscaEntrySchema((PfConceptKey) null))
+ assertThatThrownBy(() -> new JpaToscaSchemaDefinition((PfConceptKey) null))
.hasMessageMatching("type is marked .*on.*ull but is null");
- assertThatThrownBy(() -> new JpaToscaEntrySchema((JpaToscaEntrySchema) null))
+ assertThatThrownBy(() -> new JpaToscaSchemaDefinition((JpaToscaSchemaDefinition) null))
.hasMessageMatching("copyConcept is marked .*on.*ull but is null");
PfConceptKey typeKey = new PfConceptKey("type", "0.0.1");
- JpaToscaEntrySchema tes = new JpaToscaEntrySchema(typeKey);
+ JpaToscaSchemaDefinition tes = new JpaToscaSchemaDefinition(typeKey);
tes.setDescription(A_DESCRIPTION);
assertEquals(A_DESCRIPTION, tes.getDescription());
tes.setConstraints(constraints);
assertEquals(constraints, tes.getConstraints());
- JpaToscaEntrySchema tdtClone0 = new JpaToscaEntrySchema(tes);
+ JpaToscaSchemaDefinition tdtClone0 = new JpaToscaSchemaDefinition(tes);
assertEquals(tes, tdtClone0);
assertEquals(0, tes.compareTo(tdtClone0));
- JpaToscaEntrySchema tdtClone1 = new JpaToscaEntrySchema(tes);
+ JpaToscaSchemaDefinition tdtClone1 = new JpaToscaSchemaDefinition(tes);
assertEquals(tes, tdtClone1);
assertEquals(0, tes.compareTo(tdtClone1));
assertEquals(-1, tes.compareTo(null));
assertEquals(0, tes.compareTo(tes));
- JpaToscaEntrySchema otherEs = new JpaToscaEntrySchema(typeKey);
+ JpaToscaSchemaDefinition otherEs = new JpaToscaSchemaDefinition(typeKey);
assertNotEquals(0, tes.compareTo(otherEs));
otherEs.setType(typeKey);
assertThatThrownBy(() -> tes.copyTo(null)).hasMessageMatching("target is marked .*on.*ull but is null");
assertEquals(1, tes.getKeys().size());
- assertEquals(1, new JpaToscaEntrySchema(typeKey).getKeys().size());
+ assertEquals(1, new JpaToscaSchemaDefinition(typeKey).getKeys().size());
- new JpaToscaEntrySchema(typeKey).clean();
+ new JpaToscaSchemaDefinition(typeKey).clean();
tes.clean();
assertEquals(tdtClone0, tes);
- assertTrue(new JpaToscaEntrySchema(typeKey).validate(new PfValidationResult()).isValid());
+ assertTrue(new JpaToscaSchemaDefinition(typeKey).validate(new PfValidationResult()).isValid());
assertTrue(tes.validate(new PfValidationResult()).isValid());
tes.setType(PfConceptKey.getNullKey());
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
+import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;
import org.junit.Test;
JpaToscaDataType dt0 = new JpaToscaDataType(new PfConceptKey("dt0:0.0.1"));
JpaToscaProperty prop0 = new JpaToscaProperty(new PfReferenceKey(pt0.getKey(), "prop0"));
prop0.setType(dt0.getKey());
+
+ pt0.setProperties(new LinkedHashMap<>());
pt0.getProperties().put(prop0.getKey().getLocalName(), prop0);
result = tst.validate(new PfValidationResult());
assertFalse(result.isOk());
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
+import java.util.LinkedHashMap;
import java.util.Properties;
import org.eclipse.persistence.config.PersistenceUnitProperties;
import org.junit.After;
serviceTemplate.getDataTypes().getConceptMap().put(dataType0Key, dataType0);
JpaToscaServiceTemplate createdServiceTemplate =
- new SimpleToscaProvider().createDataTypes(pfDao, serviceTemplate);
+ new SimpleToscaProvider().createDataTypes(pfDao, serviceTemplate);
assertEquals(1, createdServiceTemplate.getDataTypes().getConceptMap().size());
assertEquals(dataType0, createdServiceTemplate.getDataTypes().get(dataType0Key));
dataType0.setDescription("Updated Description");
JpaToscaServiceTemplate updatedServiceTemplate =
- new SimpleToscaProvider().updateDataTypes(pfDao, serviceTemplate);
+ new SimpleToscaProvider().updateDataTypes(pfDao, serviceTemplate);
assertEquals(dataType0, updatedServiceTemplate.getDataTypes().get(dataType0Key));
assertEquals("Updated Description", updatedServiceTemplate.getDataTypes().get(dataType0Key).getDescription());
JpaToscaServiceTemplate gotServiceTemplate =
- new SimpleToscaProvider().getDataTypes(pfDao, dataType0Key.getName(), dataType0Key.getVersion());
+ new SimpleToscaProvider().getDataTypes(pfDao, dataType0Key.getName(), dataType0Key.getVersion());
assertEquals(dataType0, gotServiceTemplate.getDataTypes().get(dataType0Key));
assertEquals("Updated Description", gotServiceTemplate.getDataTypes().get(dataType0Key).getDescription());
assertThatThrownBy(() -> new SimpleToscaProvider().deleteDataType(pfDao, new PfConceptKey("IDontExist:0.0.1")))
- .hasMessage("data type IDontExist:0.0.1 not found");
+ .hasMessage("data type IDontExist:0.0.1 not found");
JpaToscaServiceTemplate deletedServiceTemplate = new SimpleToscaProvider().deleteDataType(pfDao, dataType0Key);
assertEquals("Updated Description", deletedServiceTemplate.getDataTypes().get(dataType0Key).getDescription());
assertThatThrownBy(() -> new SimpleToscaProvider().deleteDataType(pfDao, dataType0Key))
- .hasMessage("no data types found");
+ .hasMessage("no data types found");
// Create the data type again
new SimpleToscaProvider().createDataTypes(pfDao, serviceTemplate);
JpaToscaPolicyType pt0v2 = new JpaToscaPolicyType(new PfConceptKey("pt0:0.0.2"));
JpaToscaProperty prop0 = new JpaToscaProperty(new PfReferenceKey(pt0v2.getKey(), "prop0"));
prop0.setType(dataType0Key);
+ pt0v2.setProperties(new LinkedHashMap<>());
pt0v2.getProperties().put(prop0.getKey().getLocalName(), prop0);
updatedServiceTemplate.getPolicyTypes().getConceptMap().put(pt0v2.getKey(), pt0v2);
new SimpleToscaProvider().createPolicyTypes(pfDao, updatedServiceTemplate);
assertThatThrownBy(() -> new SimpleToscaProvider().deleteDataType(pfDao, dataType0Key))
- .hasMessage("data type DataType0:0.0.1 is in use, it is referenced in policy type pt0:0.0.2");
+ .hasMessage("data type DataType0:0.0.1 is in use, it is referenced in policy type pt0:0.0.2");
JpaToscaDataType dataType0v2 = new JpaToscaDataType(new PfConceptKey("DataType0:0.0.2"));
updatedServiceTemplate.getDataTypes().getConceptMap().put(dataType0v2.getKey(), dataType0v2);
assertNull(deletedServiceTemplate.getDataTypes().get(dataType0v2.getKey()).getDescription());
assertThatThrownBy(() -> new SimpleToscaProvider().deleteDataType(pfDao, dataType0Key))
- .hasMessage("data type DataType0:0.0.1 is in use, it is referenced in policy type pt0:0.0.2");
+ .hasMessage("data type DataType0:0.0.1 is in use, it is referenced in policy type pt0:0.0.2");
JpaToscaDataType dataType1 = new JpaToscaDataType(new PfConceptKey("DataType1:0.0.3"));
JpaToscaProperty prop1 = new JpaToscaProperty(new PfReferenceKey(dataType1.getKey(), "prop1"));
prop1.setType(dataType0v2.getKey());
+ dataType1.setProperties(new LinkedHashMap<>());
dataType1.getProperties().put(prop1.getKey().getLocalName(), prop1);
updatedServiceTemplate.getDataTypes().getConceptMap().put(dataType1.getKey(), dataType1);
new SimpleToscaProvider().createDataTypes(pfDao, updatedServiceTemplate);
assertThatThrownBy(() -> new SimpleToscaProvider().deleteDataType(pfDao, dataType0v2.getKey()))
- .hasMessage("data type DataType0:0.0.2 is in use, it is referenced in data type DataType1:0.0.3");
+ .hasMessage("data type DataType0:0.0.2 is in use, it is referenced in data type DataType1:0.0.3");
}
@Test
serviceTemplate.getPolicyTypes().getConceptMap().put(policyType0Key, policyType0);
JpaToscaServiceTemplate createdServiceTemplate =
- new SimpleToscaProvider().createPolicyTypes(pfDao, serviceTemplate);
+ new SimpleToscaProvider().createPolicyTypes(pfDao, serviceTemplate);
assertEquals(1, createdServiceTemplate.getPolicyTypes().getConceptMap().size());
assertEquals(policyType0, createdServiceTemplate.getPolicyTypes().get(policyType0Key));
policyType0.setDescription("Updated Description");
JpaToscaServiceTemplate updatedServiceTemplate =
- new SimpleToscaProvider().updatePolicyTypes(pfDao, serviceTemplate);
+ new SimpleToscaProvider().updatePolicyTypes(pfDao, serviceTemplate);
assertEquals(policyType0, updatedServiceTemplate.getPolicyTypes().get(policyType0Key));
assertEquals("Updated Description",
- updatedServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription());
+ updatedServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription());
JpaToscaServiceTemplate gotServiceTemplate =
- new SimpleToscaProvider().getPolicyTypes(pfDao, policyType0Key.getName(), policyType0Key.getVersion());
+ new SimpleToscaProvider().getPolicyTypes(pfDao, policyType0Key.getName(), policyType0Key.getVersion());
assertEquals(policyType0, gotServiceTemplate.getPolicyTypes().get(policyType0Key));
assertEquals("Updated Description", gotServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription());
new SimpleToscaProvider().createPolicyTypes(pfDao, serviceTemplate);
assertThatThrownBy(() -> new SimpleToscaProvider().deletePolicyType(pfDao, policyType0Key))
- .hasMessage("policy type PolicyType0:0.0.1 is in use, it is referenced in policy type pt1:0.0.2");
+ .hasMessage("policy type PolicyType0:0.0.1 is in use, it is referenced in policy type pt1:0.0.2");
serviceTemplate.setTopologyTemplate(new JpaToscaTopologyTemplate());
serviceTemplate.getTopologyTemplate().setPolicies(new JpaToscaPolicies());
new SimpleToscaProvider().createPolicies(pfDao, serviceTemplate);
assertThatThrownBy(() -> new SimpleToscaProvider().deletePolicyType(pfDao, policyType0Key))
- .hasMessage("policy type PolicyType0:0.0.1 is in use, it is referenced in policy type pt1:0.0.2");
+ .hasMessage("policy type PolicyType0:0.0.1 is in use, it is referenced in policy type pt1:0.0.2");
assertThatThrownBy(() -> new SimpleToscaProvider().deletePolicyType(pfDao, pt1.getKey()))
- .hasMessage("policy type pt1:0.0.2 is in use, it is referenced in policy p1:0.0.1");
+ .hasMessage("policy type pt1:0.0.2 is in use, it is referenced in policy p1:0.0.1");
new SimpleToscaProvider().deletePolicy(pfDao, p1.getKey());
new SimpleToscaProvider().deletePolicy(pfDao, p0.getKey());
JpaToscaServiceTemplate deletedServiceTemplate =
- new SimpleToscaProvider().deletePolicyType(pfDao, policyType0Key);
+ new SimpleToscaProvider().deletePolicyType(pfDao, policyType0Key);
assertEquals(policyType0, deletedServiceTemplate.getPolicyTypes().get(policyType0Key));
assertEquals("Updated Description",
- deletedServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription());
+ deletedServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription());
assertThatThrownBy(() -> new SimpleToscaProvider().deletePolicyType(pfDao, policyType0Key))
- .hasMessage("no policy types found");
+ .hasMessage("no policy types found");
JpaToscaServiceTemplate newServiceTemplate =
- new SimpleToscaProvider().createPolicyTypes(pfDao, serviceTemplate);
+ new SimpleToscaProvider().createPolicyTypes(pfDao, serviceTemplate);
assertEquals(serviceTemplate, newServiceTemplate);
}
serviceTemplate.getPolicyTypes().getConceptMap().put(policyType0Key, policyType0);
JpaToscaServiceTemplate createdServiceTemplate =
- new SimpleToscaProvider().createPolicyTypes(pfDao, serviceTemplate);
+ new SimpleToscaProvider().createPolicyTypes(pfDao, serviceTemplate);
assertEquals(policyType0, createdServiceTemplate.getPolicyTypes().get(policyType0Key));
assertEquals(null, createdServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription());
policyType0.setDescription("Updated Description");
JpaToscaServiceTemplate updatedServiceTemplate =
- new SimpleToscaProvider().updatePolicyTypes(pfDao, serviceTemplate);
+ new SimpleToscaProvider().updatePolicyTypes(pfDao, serviceTemplate);
assertEquals(policyType0, updatedServiceTemplate.getPolicyTypes().get(policyType0Key));
assertEquals("Updated Description",
- updatedServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription());
+ updatedServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription());
JpaToscaServiceTemplate gotServiceTemplate =
- new SimpleToscaProvider().getPolicyTypes(pfDao, policyType0Key.getName(), policyType0Key.getVersion());
+ new SimpleToscaProvider().getPolicyTypes(pfDao, policyType0Key.getName(), policyType0Key.getVersion());
assertEquals(policyType0, gotServiceTemplate.getPolicyTypes().get(policyType0Key));
assertEquals("Updated Description", gotServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription());
JpaToscaServiceTemplate deletedServiceTemplate =
- new SimpleToscaProvider().deletePolicyType(pfDao, policyType0Key);
+ new SimpleToscaProvider().deletePolicyType(pfDao, policyType0Key);
assertEquals(policyType0, deletedServiceTemplate.getPolicyTypes().get(policyType0Key));
assertEquals("Updated Description",
- deletedServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription());
+ deletedServiceTemplate.getPolicyTypes().get(policyType0Key).getDescription());
assertThatThrownBy(() -> new SimpleToscaProvider().deletePolicyType(pfDao, policyType0Key))
- .hasMessage("no policy types found");
+ .hasMessage("no policy types found");
}
@Test
public void testPoliciesGet() throws Exception {
ToscaServiceTemplate toscaServiceTemplate =
- standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class);
+ standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class);
createPolicyTypes();
assertNotNull(originalServiceTemplate);
JpaToscaServiceTemplate createdServiceTemplate =
- new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate);
+ new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate);
assertEquals(originalServiceTemplate.getTopologyTemplate().getPolicies(),
- createdServiceTemplate.getTopologyTemplate().getPolicies());
+ createdServiceTemplate.getTopologyTemplate().getPolicies());
PfConceptKey policyKey = new PfConceptKey("onap.restart.tca:1.0.0");
JpaToscaServiceTemplate gotServiceTemplate =
- new SimpleToscaProvider().getPolicies(pfDao, policyKey.getName(), policyKey.getVersion());
+ new SimpleToscaProvider().getPolicies(pfDao, policyKey.getName(), policyKey.getVersion());
- assertEquals(originalServiceTemplate.getTopologyTemplate().getPolicies().get(policyKey),
- gotServiceTemplate.getTopologyTemplate().getPolicies().get(policyKey));
+ assertEquals(0, originalServiceTemplate.getTopologyTemplate().getPolicies().get(policyKey)
+ .compareTo(gotServiceTemplate.getTopologyTemplate().getPolicies().get(policyKey)));
JpaToscaServiceTemplate deletedServiceTemplate = new SimpleToscaProvider().deletePolicy(pfDao, policyKey);
assertEquals(1, deletedServiceTemplate.getTopologyTemplate().getPolicies().getConceptMap().size());
@Test
public void testPolicyCreate() throws Exception {
ToscaServiceTemplate toscaServiceTemplate =
- standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class);
+ standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class);
createPolicyTypes();
assertNotNull(originalServiceTemplate);
JpaToscaServiceTemplate createdServiceTemplate =
- new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate);
+ new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate);
assertEquals(originalServiceTemplate.getTopologyTemplate().getPolicies(),
- createdServiceTemplate.getTopologyTemplate().getPolicies());
+ createdServiceTemplate.getTopologyTemplate().getPolicies());
}
@Test
public void testPolicyCreateTypeAndVersion() throws Exception {
ToscaServiceTemplate toscaServiceTemplate =
- standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class);
+ standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class);
createPolicyTypes();
ToscaPolicy toscaPolicy =
- toscaServiceTemplate.getToscaTopologyTemplate().getPoliciesAsMap().values().iterator().next();
+ toscaServiceTemplate.getToscaTopologyTemplate().getPoliciesAsMap().values().iterator().next();
JpaToscaServiceTemplate originalServiceTemplate = new JpaToscaServiceTemplate();
assertThatThrownBy(() -> {
originalServiceTemplate.fromAuthorative(toscaServiceTemplate);
}).hasMessage("PolicyType type not specified, the type of the PolicyType for this policy must be "
- + "specified in the type field");
+ + "specified in the type field");
toscaPolicy.setType("IDontExist");
assertThatThrownBy(() -> {
originalServiceTemplate.fromAuthorative(toscaServiceTemplate);
}).hasMessage("PolicyType version not specified, the version of the PolicyType for this policy must be "
- + "specified in the type_version field");
+ + "specified in the type_version field");
toscaPolicy.setTypeVersion("hello");
assertThatThrownBy(() -> {
assertThatThrownBy(() -> {
originalServiceTemplate.fromAuthorative(toscaServiceTemplate);
}).hasMessage("PolicyType type not specified, the type of the PolicyType for this policy must be "
- + "specified in the type field");
+ + "specified in the type field");
toscaPolicy.setType(originalPolicyType);
toscaPolicy.setTypeVersion(originalPolicyTypeVersion);
originalServiceTemplate.fromAuthorative(toscaServiceTemplate);
JpaToscaServiceTemplate createdServiceTemplate =
- new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate);
+ new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate);
assertEquals(originalServiceTemplate.getTopologyTemplate().getPolicies(),
- createdServiceTemplate.getTopologyTemplate().getPolicies());
+ createdServiceTemplate.getTopologyTemplate().getPolicies());
}
@Test
public void testPolicyUpdate() throws Exception {
ToscaServiceTemplate toscaServiceTemplate =
- standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class);
+ standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class);
createPolicyTypes();
assertNotNull(originalServiceTemplate);
JpaToscaServiceTemplate updatedServiceTemplate =
- new SimpleToscaProvider().updatePolicies(pfDao, originalServiceTemplate);
+ new SimpleToscaProvider().updatePolicies(pfDao, originalServiceTemplate);
assertEquals(originalServiceTemplate, updatedServiceTemplate);
}
@Test
public void testPoliciesDelete() throws Exception {
ToscaServiceTemplate toscaServiceTemplate =
- standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class);
+ standardCoder.decode(ResourceUtils.getResourceAsString(VCPE_INPUT_JSON), ToscaServiceTemplate.class);
createPolicyTypes();
assertNotNull(originalServiceTemplate);
JpaToscaServiceTemplate createdServiceTemplate =
- new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate);
+ new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate);
assertEquals(originalServiceTemplate.getTopologyTemplate(), createdServiceTemplate.getTopologyTemplate());
PfConceptKey policyKey = new PfConceptKey("onap.restart.tca:1.0.0");
assertThatThrownBy(() -> new SimpleToscaProvider().deletePolicy(pfDao, new PfConceptKey("IDontExist:0.0.1")))
- .hasMessage("policy IDontExist:0.0.1 not found");
+ .hasMessage("policy IDontExist:0.0.1 not found");
JpaToscaServiceTemplate deletedServiceTemplate = new SimpleToscaProvider().deletePolicy(pfDao, policyKey);
- assertEquals(originalServiceTemplate.getTopologyTemplate().getPolicies().get(policyKey),
- deletedServiceTemplate.getTopologyTemplate().getPolicies().get(policyKey));
+ assertEquals(0, originalServiceTemplate.getTopologyTemplate().getPolicies().get(policyKey)
+ .compareTo(deletedServiceTemplate.getTopologyTemplate().getPolicies().get(policyKey)));
assertThatThrownBy(() -> {
new SimpleToscaProvider().getPolicies(pfDao, policyKey.getName(), policyKey.getVersion());
}).hasMessage("policies for onap.restart.tca:1.0.0 do not exist");
assertThatThrownBy(() -> new SimpleToscaProvider().deletePolicy(pfDao, policyKey))
- .hasMessage("no policies found");
+ .hasMessage("no policies found");
new SimpleToscaProvider().createPolicies(pfDao, originalServiceTemplate);
}
JpaToscaServiceTemplate testServiceTemplate = new JpaToscaServiceTemplate();
assertThatThrownBy(() -> new SimpleToscaProvider().createPolicies(pfDao, testServiceTemplate))
- .hasMessage("topology template not specified on service template");
+ .hasMessage("topology template not specified on service template");
testServiceTemplate.setTopologyTemplate(new JpaToscaTopologyTemplate());
assertThatThrownBy(() -> new SimpleToscaProvider().createPolicies(pfDao, testServiceTemplate))
- .hasMessage("no policies specified on topology template of service template");
+ .hasMessage("no policies specified on topology template of service template");
testServiceTemplate.getTopologyTemplate().setPolicies(new JpaToscaPolicies());
assertThatThrownBy(() -> new SimpleToscaProvider().createPolicies(pfDao, testServiceTemplate))
- .hasMessage("list of policies specified on topology template of service template is empty");
+ .hasMessage("list of policies specified on topology template of service template is empty");
}
@Test
public void testGetServiceTemplate() throws PfModelException {
assertThatThrownBy(() -> new SimpleToscaProvider().getServiceTemplate(pfDao))
- .hasMessage("service template not found in database");
+ .hasMessage("service template not found in database");
}
@Test
serviceTemplateFragment.getPolicyTypes().getConceptMap().put(badPt.getKey(), badPt);
assertThatThrownBy(() -> new SimpleToscaProvider().appendToServiceTemplate(pfDao, serviceTemplateFragment))
- .hasMessageContaining(
- "key on concept entry PfConceptKey(name=NULL, version=0.0.0) may not be the null key");
+ .hasMessageContaining(
+ "key on concept entry PfConceptKey(name=NULL, version=0.0.0) may not be the null key");
}
@Test
}).hasMessageMatching("policy types for hello:0.0.1 do not exist");
JpaToscaServiceTemplate gotSt =
- new SimpleToscaProvider().getPolicyTypes(pfDao, pt01.getName(), pt01.getVersion());
+ new SimpleToscaProvider().getPolicyTypes(pfDao, pt01.getName(), pt01.getVersion());
assertEquals(pt01, gotSt.getPolicyTypes().get(pt01.getKey()));
assertEquals(pt01, gotSt.getPolicyTypes().get(pt01.getName()));
JpaToscaServiceTemplate gotSt = new SimpleToscaProvider().getPolicies(pfDao, p01.getName(), p01.getVersion());
- assertEquals(p01, gotSt.getTopologyTemplate().getPolicies().get(p01.getKey()));
- assertEquals(p01, gotSt.getTopologyTemplate().getPolicies().get(p01.getName()));
- assertEquals(p01, gotSt.getTopologyTemplate().getPolicies().get(p01.getName(), null));
- assertEquals(p01, gotSt.getTopologyTemplate().getPolicies().get(p01.getName(), p01.getVersion()));
+ assertEquals(0, p01.compareTo(gotSt.getTopologyTemplate().getPolicies().get(p01.getKey())));
+ assertEquals(0, p01.compareTo(gotSt.getTopologyTemplate().getPolicies().get(p01.getName())));
+ assertEquals(0, p01.compareTo(gotSt.getTopologyTemplate().getPolicies().get(p01.getName(), null)));
+ assertEquals(0, p01.compareTo(gotSt.getTopologyTemplate().getPolicies().get(p01.getName(), p01.getVersion())));
assertEquals(1, gotSt.getTopologyTemplate().getPolicies().getAll(null).size());
assertEquals(1, gotSt.getTopologyTemplate().getPolicies().getAll(null, null).size());
assertEquals(1, gotSt.getTopologyTemplate().getPolicies().getAll(p01.getName(), null).size());
serviceTemplate.getDataTypes().getConceptMap().put(dataType0Key, dataType0);
JpaToscaServiceTemplate createdServiceTemplate =
- new SimpleToscaProvider().createDataTypes(pfDao, serviceTemplate);
+ new SimpleToscaProvider().createDataTypes(pfDao, serviceTemplate);
assertEquals(1, createdServiceTemplate.getDataTypes().getConceptMap().size());
assertEquals(dataType0, createdServiceTemplate.getDataTypes().get(dataType0Key));
}
private void createPolicyTypes() throws CoderException, PfModelException {
- Object yamlObject = new Yaml()
- .load(ResourceUtils.getResourceAsString("policytypes/onap.policies.monitoring.tcagen2.yaml"));
+ Object yamlObject =
+ new Yaml().load(ResourceUtils.getResourceAsString("policytypes/onap.policies.monitoring.tcagen2.yaml"));
String yamlAsJsonString = new StandardCoder().encode(yamlObject);
ToscaServiceTemplate toscaServiceTemplatePolicyType =
- standardCoder.decode(yamlAsJsonString, ToscaServiceTemplate.class);
+ standardCoder.decode(yamlAsJsonString, ToscaServiceTemplate.class);
assertNotNull(toscaServiceTemplatePolicyType);
new AuthorativeToscaProvider().createPolicyTypes(pfDao, toscaServiceTemplatePolicyType);
import java.util.List;
import java.util.Map;
+import org.apache.commons.collections4.MapUtils;
import org.junit.Before;
import org.junit.Test;
import org.onap.policy.common.utils.coder.CoderException;
String testnm = testName + " identity";
assertNotNull(testnm, prop);
- assertEquals(testnm + " metadata", 0, prop.getMetadata().size());
+ assertEquals(testnm + " metadata", true, MapUtils.isEmpty(prop.getMetadata()));
}
private void validateMatchable(String testName, Map<String, String> metadata) {
<persistence-unit name="ToscaConceptTest" transaction-type="RESOURCE_LOCAL">
<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
+ <class>org.onap.policy.models.base.PfConceptKey</class>
<class>org.onap.policy.models.dao.converters.CDataConditioner</class>
<class>org.onap.policy.models.dao.converters.Uuid2String</class>
- <class>org.onap.policy.models.base.PfConceptKey</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaCapabilityAssignment</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaCapabilityAssignments</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaCapabilityType</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaCapabilityTypes</class>
<class>org.onap.policy.models.tosca.simple.concepts.JpaToscaDataType</class>
<class>org.onap.policy.models.tosca.simple.concepts.JpaToscaDataTypes</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTemplate</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTemplates</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeType</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTypes</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaParameter</class>
<class>org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicies</class>
<class>org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicy</class>
<class>org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicyType</class>
<class>org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicyTypes</class>
- <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaTopologyTemplate</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaProperty</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaRelationshipType</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaRelationshipTypes</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaRequirement</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaRequirements</class>
<class>org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate</class>
+ <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaTopologyTemplate</class>
<class>org.onap.policy.models.tosca.simple.concepts.JpaToscaTrigger</class>
- <class>org.onap.policy.models.tosca.simple.concepts.JpaToscaProperty</class>
<properties>
<property name="eclipselink.ddl-generation" value="drop-and-create-tables" />
Code Review / policy / models.git / commitdiff