JPA concepts for TOSCA

Implement the Database persistence parts for the new TOSCA concepts so
that those concepts can be written to and read from the database.

First batch of comment fixes

Issue-ID: POLICY-2900
Change-Id: I45191c1ff57cf1ea8563399db6cc8e51b2724813
Signed-off-by: liamfallon <liam.fallon@est.tech>

36 files changed, 3222 insertions, 321 deletions

diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignment.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignment.java
new file mode 100644
index 000000000..63945174a
--- /dev/null
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignment.java
@@ -0,0 +1,271 @@
+/*-
+ * ============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);
+    }
+}
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignments.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignments.java
new file mode 100644
index 000000000..5afc89275
--- /dev/null
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignments.java
@@ -0,0 +1,117 @@
+/*-
+ * ============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;
+    }
+}
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityType.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityType.java
new file mode 100644
index 000000000..4db779557
--- /dev/null
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityType.java
@@ -0,0 +1,239 @@
+/*-
+ * ============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;
+    }
+}
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityTypes.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityTypes.java
new file mode 100644
index 000000000..6ec6de56e
--- /dev/null
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityTypes.java
@@ -0,0 +1,112 @@
+/*-
+ * ============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;
+    }
+}
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaDataType.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaDataType.java
index 4e4cb8e84..58ac9e326 100644
--- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaDataType.java
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaDataType.java
@@ -50,7 +50,6 @@ 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.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;
@@ -70,11 +69,11 @@ public class JpaToscaDataType extends JpaToscaEntityType<ToscaDataType> implemen
     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.
@@ -119,25 +118,8 @@ public class JpaToscaDataType extends JpaToscaEntityType<ToscaDataType> implemen
         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;
     }
@@ -146,13 +128,7 @@ public class JpaToscaDataType extends JpaToscaEntityType<ToscaDataType> implemen
     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<>();
@@ -220,7 +196,7 @@ public class JpaToscaDataType extends JpaToscaEntityType<ToscaDataType> implemen
     /**
      * 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) {
@@ -250,21 +226,17 @@ public class JpaToscaDataType extends JpaToscaEntityType<ToscaDataType> implemen
         }
 
         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);
     }
 
     /**
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntityType.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntityType.java
index 76d2ff951..549d93e8a 100644
--- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntityType.java
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntityType.java
@@ -21,7 +21,6 @@
 
 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;
@@ -70,7 +69,7 @@ public class JpaToscaEntityType<T extends ToscaEntity> extends PfConcept impleme
     private PfConceptKey derivedFrom;
 
     @ElementCollection
-    private Map<String, String> metadata = new TreeMap<>();
+    private Map<String, String> metadata;
 
     @Column
     private String description;
@@ -129,15 +128,7 @@ public class JpaToscaEntityType<T extends ToscaEntity> extends PfConcept impleme
             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;
     }
@@ -155,7 +146,7 @@ public class JpaToscaEntityType<T extends ToscaEntity> extends PfConcept impleme
         }
 
         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 {
@@ -167,13 +158,7 @@ public class JpaToscaEntityType<T extends ToscaEntity> extends PfConcept impleme
             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
@@ -253,16 +238,18 @@ public class JpaToscaEntityType<T extends ToscaEntity> extends PfConcept impleme
 
         @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;
         }
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEventFilter.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEventFilter.java
index 716813799..90bb0a89e 100644
--- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEventFilter.java
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEventFilter.java
@@ -3,7 +3,7 @@
  * 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.
@@ -165,19 +165,21 @@ public class JpaToscaEventFilter extends PfConcept {
         }
 
         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
+}
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaModel.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaModel.java
index cc9b1bc96..d65689d8e 100644
--- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaModel.java
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaModel.java
@@ -1,6 +1,6 @@
 /*-
  * ============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");
@@ -40,9 +40,8 @@ import org.onap.policy.models.base.PfModelService;
 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.
  */
@@ -59,16 +58,16 @@ public class JpaToscaModel extends PfModel {
     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
      */
@@ -139,8 +138,9 @@ public class JpaToscaModel extends PfModel {
         }
 
         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);
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTemplate.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTemplate.java
new file mode 100644
index 000000000..5fccbe27a
--- /dev/null
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTemplate.java
@@ -0,0 +1,310 @@
+/*-
+ * ============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);
+    }
+}
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTemplates.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTemplates.java
new file mode 100644
index 000000000..6c83f67c5
--- /dev/null
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTemplates.java
@@ -0,0 +1,112 @@
+/*-
+ * ============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;
+    }
+}
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeType.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeType.java
new file mode 100644
index 000000000..26684b583
--- /dev/null
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeType.java
@@ -0,0 +1,277 @@
+/*-
+ * ============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;
+    }
+}
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTypes.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTypes.java
new file mode 100644
index 000000000..5eb5a2c49
--- /dev/null
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaNodeTypes.java
@@ -0,0 +1,112 @@
+/*-
+ * ============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;
+    }
+}
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaParameter.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaParameter.java
new file mode 100644
index 000000000..216e877cc
--- /dev/null
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaParameter.java
@@ -0,0 +1,202 @@
+/*-
+ * ============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);
+    }
+}
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicy.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicy.java
index 689d03506..518a0884b 100644
--- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicy.java
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicy.java
@@ -23,7 +23,6 @@
 
 package org.onap.policy.models.tosca.simple.concepts;
 
-import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -73,6 +72,8 @@ public class JpaToscaPolicy extends JpaToscaEntityType<ToscaPolicy> implements P
     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({
@@ -85,10 +86,10 @@ public class JpaToscaPolicy extends JpaToscaEntityType<ToscaPolicy> implements P
 
     @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
 
     /**
@@ -155,28 +156,14 @@ public class JpaToscaPolicy extends JpaToscaEntityType<ToscaPolicy> implements P
             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;
     }
@@ -189,38 +176,26 @@ public class JpaToscaPolicy extends JpaToscaEntityType<ToscaPolicy> implements P
             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) {
@@ -264,12 +239,12 @@ public class JpaToscaPolicy extends JpaToscaEntityType<ToscaPolicy> implements P
 
         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);
         }
@@ -295,10 +270,10 @@ public class JpaToscaPolicy extends JpaToscaEntityType<ToscaPolicy> implements P
         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 "));
             }
         }
     }
@@ -306,7 +281,7 @@ public class JpaToscaPolicy extends JpaToscaEntityType<ToscaPolicy> implements P
     /**
      * 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) {
@@ -315,7 +290,7 @@ public class JpaToscaPolicy extends JpaToscaEntityType<ToscaPolicy> implements P
         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);
             }
@@ -338,19 +313,21 @@ public class JpaToscaPolicy extends JpaToscaEntityType<ToscaPolicy> implements P
         }
 
         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);
     }
 }
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyType.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyType.java
index 93bfd2a94..7a5493ce1 100644
--- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyType.java
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyType.java
@@ -23,7 +23,6 @@
 
 package org.onap.policy.models.tosca.simple.concepts;
 
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
@@ -71,13 +70,13 @@ public class JpaToscaPolicyType extends JpaToscaEntityType<ToscaPolicyType> impl
 
     @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.
@@ -122,15 +121,7 @@ public class JpaToscaPolicyType extends JpaToscaEntityType<ToscaPolicyType> impl
         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;
     }
@@ -293,21 +284,22 @@ public class JpaToscaPolicyType extends JpaToscaEntityType<ToscaPolicyType> impl
         }
 
         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);
     }
 
     /**
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaProperty.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaProperty.java
index 48ee9d4a2..c56dc6a42 100644
--- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaProperty.java
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaProperty.java
@@ -27,7 +27,6 @@ import java.util.ArrayList;
 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;
@@ -49,7 +48,6 @@ 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.ToscaConstraint;
 import org.onap.policy.models.tosca.authorative.concepts.ToscaProperty;
 import org.onap.policy.models.tosca.authorative.concepts.ToscaProperty.Status;
 
@@ -86,13 +84,13 @@ public class JpaToscaProperty extends PfConcept implements PfAuthorative<ToscaPr
     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.
@@ -113,7 +111,7 @@ public class JpaToscaProperty extends PfConcept implements PfAuthorative<ToscaPr
     /**
      * 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) {
@@ -136,7 +134,8 @@ public class JpaToscaProperty extends PfConcept implements PfAuthorative<ToscaPr
         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);
     }
 
@@ -166,23 +165,13 @@ public class JpaToscaProperty extends PfConcept implements PfAuthorative<ToscaPr
             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;
     }
@@ -208,23 +197,13 @@ public class JpaToscaProperty extends PfConcept implements PfAuthorative<ToscaPr
             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
@@ -258,11 +237,7 @@ public class JpaToscaProperty extends PfConcept implements PfAuthorative<ToscaPr
             entrySchema.clean();
         }
 
-        if (metadata != null) {
-            for (Entry<String, String> metadataEntry : metadata.entrySet()) {
-                metadataEntry.setValue(metadataEntry.getValue().trim());
-            }
-        }
+        metadata = PfUtils.mapMap(metadata, String::trim);
     }
 
     @Override
@@ -271,14 +246,14 @@ public class JpaToscaProperty extends PfConcept implements PfAuthorative<ToscaPr
 
         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);
@@ -295,19 +270,19 @@ public class JpaToscaProperty extends PfConcept implements PfAuthorative<ToscaPr
 
         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 "));
                 }
             }
         }
@@ -364,11 +339,16 @@ public class JpaToscaProperty extends PfConcept implements PfAuthorative<ToscaPr
             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);
     }
 }
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRelationshipType.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRelationshipType.java
new file mode 100644
index 000000000..d3d06d4a0
--- /dev/null
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRelationshipType.java
@@ -0,0 +1,236 @@
+/*-
+ * ============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;
+    }
+}
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRelationshipTypes.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRelationshipTypes.java
new file mode 100644
index 000000000..28e1d602c
--- /dev/null
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRelationshipTypes.java
@@ -0,0 +1,113 @@
+/*-
+ * ============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;
+    }
+}
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRequirement.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRequirement.java
new file mode 100644
index 000000000..aebc31caf
--- /dev/null
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRequirement.java
@@ -0,0 +1,303 @@
+/*-
+ * ============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);
+    }
+}
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRequirements.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRequirements.java
new file mode 100644
index 000000000..08dbb43de
--- /dev/null
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaRequirements.java
@@ -0,0 +1,116 @@
+/*-
+ * ============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;
+    }
+}
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntrySchema.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaSchemaDefinition.java
index ef6aa7e92..6bd1b44cd 100644
--- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntrySchema.java
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaSchemaDefinition.java
@@ -53,8 +53,8 @@ import org.onap.policy.models.tosca.authorative.concepts.ToscaSchemaDefinition;
 @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;
 
@@ -68,14 +68,14 @@ public class JpaToscaEntrySchema
     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;
     }
 
@@ -84,7 +84,7 @@ public class JpaToscaEntrySchema
      *
      * @param copyConcept the concept to copy from
      */
-    public JpaToscaEntrySchema(@NonNull final JpaToscaEntrySchema copyConcept) {
+    public JpaToscaSchemaDefinition(@NonNull final JpaToscaSchemaDefinition copyConcept) {
         copyConcept.copyTo(this);
     }
 
@@ -93,7 +93,7 @@ public class JpaToscaEntrySchema
      *
      * @param authorativeConcept the authorative concept to copy from
      */
-    public JpaToscaEntrySchema(final ToscaSchemaDefinition authorativeConcept) {
+    public JpaToscaSchemaDefinition(final ToscaSchemaDefinition authorativeConcept) {
         this.fromAuthorative(authorativeConcept);
     }
 
@@ -180,7 +180,7 @@ public class JpaToscaEntrySchema
     }
 
     @Override
-    public int compareTo(final JpaToscaEntrySchema other) {
+    public int compareTo(final JpaToscaSchemaDefinition other) {
         if (other == null) {
             return -1;
         }
@@ -193,7 +193,7 @@ public class JpaToscaEntrySchema
             return result;
         }
 
-        return PfUtils.compareObjects(constraints, other.constraints);
+        return PfUtils.compareCollections(constraints, other.constraints);
     }
 
     /**
@@ -202,10 +202,10 @@ public class JpaToscaEntrySchema
      * @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);
 
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaServiceTemplate.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaServiceTemplate.java
index f1a6a395f..791801616 100644
--- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaServiceTemplate.java
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaServiceTemplate.java
@@ -49,8 +49,11 @@ import org.onap.policy.models.base.PfKey;
 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;
 
 /**
@@ -91,6 +94,36 @@ public class JpaToscaServiceTemplate extends JpaToscaEntityType<ToscaServiceTemp
     @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(
+            {
                 @JoinColumn(name = "policyTypesName",    referencedColumnName = "name"),
                 @JoinColumn(name = "policyTypesVersion", referencedColumnName = "version")
             }
@@ -147,6 +180,12 @@ public class JpaToscaServiceTemplate extends JpaToscaEntityType<ToscaServiceTemp
         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)
@@ -179,6 +218,30 @@ public class JpaToscaServiceTemplate extends JpaToscaEntityType<ToscaServiceTemp
             }
         }
 
+        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();
@@ -213,6 +276,21 @@ public class JpaToscaServiceTemplate extends JpaToscaEntityType<ToscaServiceTemp
             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()));
@@ -232,6 +310,18 @@ public class JpaToscaServiceTemplate extends JpaToscaEntityType<ToscaServiceTemp
             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());
         }
@@ -251,6 +341,18 @@ public class JpaToscaServiceTemplate extends JpaToscaEntityType<ToscaServiceTemp
             dataTypes.clean();
         }
 
+        if (capabilityTypes != null) {
+            capabilityTypes.clean();
+        }
+
+        if (relationshipTypes != null) {
+            relationshipTypes.clean();
+        }
+
+        if (nodeTypes != null) {
+            nodeTypes.clean();
+        }
+
         if (policyTypes != null) {
             policyTypes.clean();
         }
@@ -273,6 +375,18 @@ public class JpaToscaServiceTemplate extends JpaToscaEntityType<ToscaServiceTemp
             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);
         }
@@ -305,6 +419,21 @@ public class JpaToscaServiceTemplate extends JpaToscaEntityType<ToscaServiceTemp
             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;
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaTimeInterval.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaTimeInterval.java
index 5e5d01460..783e2b576 100644
--- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaTimeInterval.java
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaTimeInterval.java
@@ -3,7 +3,7 @@
  * 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.
@@ -159,13 +159,14 @@ public class JpaToscaTimeInterval extends PfConcept {
         }
 
         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);
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaTopologyTemplate.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaTopologyTemplate.java
index 6072054bc..32c459cc9 100644
--- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaTopologyTemplate.java
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaTopologyTemplate.java
@@ -21,9 +21,14 @@
 
 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;
@@ -31,6 +36,7 @@ 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;
@@ -41,9 +47,12 @@ import org.onap.policy.models.base.PfAuthorative;
 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;
 
 /**
@@ -69,6 +78,20 @@ public class JpaToscaTopologyTemplate extends PfConcept implements PfAuthorative
     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(
             {
@@ -105,6 +128,9 @@ public class JpaToscaTopologyTemplate extends PfConcept implements PfAuthorative
         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);
     }
 
@@ -123,6 +149,24 @@ public class JpaToscaTopologyTemplate extends PfConcept implements PfAuthorative
 
         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());
         }
@@ -134,6 +178,20 @@ public class JpaToscaTopologyTemplate extends PfConcept implements PfAuthorative
     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());
@@ -144,6 +202,16 @@ public class JpaToscaTopologyTemplate extends PfConcept implements PfAuthorative
     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());
         }
@@ -157,6 +225,16 @@ public class JpaToscaTopologyTemplate extends PfConcept implements PfAuthorative
 
         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();
         }
@@ -178,6 +256,15 @@ public class JpaToscaTopologyTemplate extends PfConcept implements PfAuthorative
                     "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);
         }
@@ -185,6 +272,26 @@ public class JpaToscaTopologyTemplate extends PfConcept implements PfAuthorative
         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);
@@ -192,11 +299,23 @@ public class JpaToscaTopologyTemplate extends PfConcept implements PfAuthorative
             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
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaTrigger.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaTrigger.java
index 417e83fe0..10a9d2f66 100644
--- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaTrigger.java
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaTrigger.java
@@ -3,7 +3,7 @@
  * 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.
@@ -137,7 +137,7 @@ public class JpaToscaTrigger extends PfConcept {
         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;
@@ -245,16 +245,16 @@ public class JpaToscaTrigger extends PfConcept {
         }
 
         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
      */
diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/utils/ToscaServiceTemplateUtils.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/utils/ToscaServiceTemplateUtils.java
index 5b6855d95..7bf4d29e8 100644
--- a/models-tosca/src/main/java/org/onap/policy/models/tosca/utils/ToscaServiceTemplateUtils.java
+++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/utils/ToscaServiceTemplateUtils.java
@@ -125,9 +125,9 @@ public class ToscaServiceTemplateUtils {
 
         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"));
diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignmentTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignmentTest.java
new file mode 100644
index 000000000..ee2fee86b
--- /dev/null
+++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaCapabilityAssignmentTest.java
@@ -0,0 +1,158 @@
+/*-
+ * ============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);
+    }
+}
diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaDataTypeTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaDataTypeTest.java
index e00e48f21..7168f488c 100644
--- a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaDataTypeTest.java
+++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaDataTypeTest.java
@@ -174,7 +174,7 @@ public class JpaToscaDataTypeTest {
 
         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());
 
@@ -183,7 +183,7 @@ public class JpaToscaDataTypeTest {
 
         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());
 
diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyTest.java
index 14a0b6a96..7f356224f 100644
--- a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyTest.java
+++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyTest.java
@@ -30,11 +30,13 @@ import static org.junit.Assert.assertTrue;
 
 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;
 
@@ -60,8 +62,8 @@ public class JpaToscaPolicyTest {
         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);
@@ -182,4 +184,44 @@ public class JpaToscaPolicyTest {
         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
+    }
 }
diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyTypeTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyTypeTest.java
index 5a18902d0..43cacda19 100644
--- a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyTypeTest.java
+++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPolicyTypeTest.java
@@ -221,7 +221,7 @@ public class JpaToscaPolicyTypeTest {
 
         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());
 
@@ -230,7 +230,7 @@ public class JpaToscaPolicyTypeTest {
 
         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());
 
diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPropertyTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPropertyTest.java
index ac2f6030f..0fa0d3f14 100644
--- a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPropertyTest.java
+++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaPropertyTest.java
@@ -91,7 +91,7 @@ public class JpaToscaPropertyTest {
         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<>();
@@ -134,6 +134,8 @@ public class JpaToscaPropertyTest {
         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);
@@ -220,7 +222,7 @@ public class JpaToscaPropertyTest {
         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<>();
diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntrySchemaTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaSchemaDefinitionTest.java
index 83d6aad97..e7163f756 100644
--- a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaEntrySchemaTest.java
+++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaSchemaDefinitionTest.java
@@ -39,23 +39,23 @@ import org.onap.policy.models.base.PfValidationResult;
  *
  * @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());
@@ -66,18 +66,18 @@ public class JpaToscaEntrySchemaTest {
         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);
@@ -90,13 +90,13 @@ public class JpaToscaEntrySchemaTest {
         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());
diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaServiceTemplateTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaServiceTemplateTest.java
index 65d832b98..bb0d2dcb5 100644
--- a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaServiceTemplateTest.java
+++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/concepts/JpaToscaServiceTemplateTest.java
@@ -29,6 +29,7 @@ import static org.junit.Assert.assertNotEquals;
 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;
@@ -154,6 +155,8 @@ public class JpaToscaServiceTemplateTest {
         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());
diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/provider/SimpleToscaProviderTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/provider/SimpleToscaProviderTest.java
index 1e18f12d4..3c363b364 100644
--- a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/provider/SimpleToscaProviderTest.java
+++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/provider/SimpleToscaProviderTest.java
@@ -26,6 +26,7 @@ import static org.junit.Assert.assertEquals;
 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;
@@ -119,7 +120,7 @@ public class SimpleToscaProviderTest {
         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));
@@ -128,19 +129,19 @@ public class SimpleToscaProviderTest {
         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);
 
@@ -161,7 +162,7 @@ public class SimpleToscaProviderTest {
         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);
@@ -169,12 +170,13 @@ public class SimpleToscaProviderTest {
         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);
@@ -186,17 +188,18 @@ public class SimpleToscaProviderTest {
         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
@@ -216,7 +219,7 @@ public class SimpleToscaProviderTest {
         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));
@@ -225,14 +228,14 @@ public class SimpleToscaProviderTest {
         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());
@@ -247,7 +250,7 @@ public class SimpleToscaProviderTest {
         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());
@@ -262,10 +265,10 @@ public class SimpleToscaProviderTest {
         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());
 
@@ -274,17 +277,17 @@ public class SimpleToscaProviderTest {
         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);
     }
 
@@ -299,7 +302,7 @@ public class SimpleToscaProviderTest {
         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());
@@ -307,33 +310,33 @@ public class SimpleToscaProviderTest {
         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();
 
@@ -342,18 +345,18 @@ public class SimpleToscaProviderTest {
 
         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());
@@ -362,7 +365,7 @@ public class SimpleToscaProviderTest {
     @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();
 
@@ -371,21 +374,21 @@ public class SimpleToscaProviderTest {
 
         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();
 
@@ -397,13 +400,13 @@ public class SimpleToscaProviderTest {
         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(() -> {
@@ -425,22 +428,22 @@ public class SimpleToscaProviderTest {
         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();
 
@@ -449,7 +452,7 @@ public class SimpleToscaProviderTest {
 
         assertNotNull(originalServiceTemplate);
         JpaToscaServiceTemplate updatedServiceTemplate =
-            new SimpleToscaProvider().updatePolicies(pfDao, originalServiceTemplate);
+                new SimpleToscaProvider().updatePolicies(pfDao, originalServiceTemplate);
 
         assertEquals(originalServiceTemplate, updatedServiceTemplate);
     }
@@ -457,7 +460,7 @@ public class SimpleToscaProviderTest {
     @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();
 
@@ -466,26 +469,26 @@ public class SimpleToscaProviderTest {
 
         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);
     }
@@ -495,21 +498,21 @@ public class SimpleToscaProviderTest {
         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
@@ -520,8 +523,8 @@ public class SimpleToscaProviderTest {
         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
@@ -609,7 +612,7 @@ public class SimpleToscaProviderTest {
         }).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()));
@@ -674,10 +677,10 @@ public class SimpleToscaProviderTest {
 
         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());
@@ -859,7 +862,7 @@ public class SimpleToscaProviderTest {
         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));
@@ -878,12 +881,12 @@ public class SimpleToscaProviderTest {
     }
 
     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);
diff --git a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/serialization/OptimizationPolicyTypeSerializationTest.java b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/serialization/OptimizationPolicyTypeSerializationTest.java
index f74fad4b4..ba486035c 100644
--- a/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/serialization/OptimizationPolicyTypeSerializationTest.java
+++ b/models-tosca/src/test/java/org/onap/policy/models/tosca/simple/serialization/OptimizationPolicyTypeSerializationTest.java
@@ -25,6 +25,7 @@ import static org.junit.Assert.assertTrue;
 
 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;
@@ -194,7 +195,7 @@ public class OptimizationPolicyTypeSerializationTest {
         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) {
diff --git a/models-tosca/src/test/resources/META-INF/persistence.xml b/models-tosca/src/test/resources/META-INF/persistence.xml
index de27dd9bc..d6ebf4eb5 100644
--- a/models-tosca/src/test/resources/META-INF/persistence.xml
+++ b/models-tosca/src/test/resources/META-INF/persistence.xml
@@ -23,19 +23,32 @@
     <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" />