2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
6 * Modifications Copyright (C) 2019 Nordix Foundation.
7 * ================================================================================
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
20 * SPDX-License-Identifier: Apache-2.0
21 * ============LICENSE_END=========================================================
24 package org.onap.policy.models.pdp.persistence.concepts;
26 import java.util.ArrayList;
27 import java.util.LinkedHashMap;
28 import java.util.List;
30 import java.util.Map.Entry;
32 import javax.persistence.CascadeType;
33 import javax.persistence.CollectionTable;
34 import javax.persistence.Column;
35 import javax.persistence.ElementCollection;
36 import javax.persistence.EmbeddedId;
37 import javax.persistence.Entity;
38 import javax.persistence.FetchType;
39 import javax.persistence.Inheritance;
40 import javax.persistence.InheritanceType;
41 import javax.persistence.JoinColumn;
42 import javax.persistence.OneToMany;
43 import javax.persistence.Table;
46 import lombok.EqualsAndHashCode;
47 import lombok.NonNull;
49 import org.apache.commons.lang3.ObjectUtils;
50 import org.apache.commons.lang3.StringUtils;
51 import org.onap.policy.common.utils.validation.Assertions;
52 import org.onap.policy.common.utils.validation.ParameterValidationUtils;
53 import org.onap.policy.models.base.PfAuthorative;
54 import org.onap.policy.models.base.PfConcept;
55 import org.onap.policy.models.base.PfConceptKey;
56 import org.onap.policy.models.base.PfKey;
57 import org.onap.policy.models.base.PfReferenceKey;
58 import org.onap.policy.models.base.PfUtils;
59 import org.onap.policy.models.base.PfValidationMessage;
60 import org.onap.policy.models.base.PfValidationResult;
61 import org.onap.policy.models.base.PfValidationResult.ValidationResult;
62 import org.onap.policy.models.pdp.concepts.PdpGroup;
63 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
64 import org.onap.policy.models.pdp.enums.PdpState;
67 * Class to represent a PDP group in the database.
69 * @author Liam Fallon (liam.fallon@est.tech)
72 @Table(name = "PdpGroup")
73 @Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
75 @EqualsAndHashCode(callSuper = false)
76 public class JpaPdpGroup extends PfConcept implements PfAuthorative<PdpGroup> {
77 private static final long serialVersionUID = -357224425637789775L;
80 private PfConceptKey key;
83 private String description;
86 private PdpState pdpGroupState;
89 private Map<String, String> properties;
92 @OneToMany(fetch = FetchType.EAGER, cascade = CascadeType.ALL, orphanRemoval = true)
93 @CollectionTable(joinColumns = {
94 @JoinColumn(name = "pdpGroupParentKeyName", referencedColumnName = "parentKeyName"),
95 @JoinColumn(name = "pdpGroupParentKeyVersion", referencedColumnName = "parentKeyVersion"),
96 @JoinColumn(name = "pdpGroupParentLocalName", referencedColumnName = "parentLocalName"),
97 @JoinColumn(name = "pdpGroupLocalName", referencedColumnName = "localName")
100 private List<JpaPdpSubGroup> pdpSubGroups;
103 * The Default Constructor creates a {@link JpaPdpGroup} object with a null key.
105 public JpaPdpGroup() {
106 this(new PfConceptKey());
110 * The Key Constructor creates a {@link JpaPdpGroup} object with the given concept key.
114 public JpaPdpGroup(@NonNull final PfConceptKey key) {
115 this(key, PdpState.PASSIVE, new ArrayList<>());
119 * The Key Constructor creates a {@link JpaPdpGroup} object with all mandatory fields.
122 * @param pdpGroupState State of the PDP group
124 public JpaPdpGroup(@NonNull final PfConceptKey key, @NonNull final PdpState pdpGroupState,
125 @NonNull final List<JpaPdpSubGroup> pdpSubGroups) {
127 this.pdpGroupState = pdpGroupState;
128 this.pdpSubGroups = pdpSubGroups;
134 * @param copyConcept the concept to copy from
136 public JpaPdpGroup(@NonNull final JpaPdpGroup copyConcept) {
141 * Authorative constructor.
143 * @param authorativeConcept the authorative concept to copy from
145 public JpaPdpGroup(@NonNull final PdpGroup authorativeConcept) {
146 this.fromAuthorative(authorativeConcept);
150 public PdpGroup toAuthorative() {
151 PdpGroup pdpGroup = new PdpGroup();
153 pdpGroup.setName(getKey().getName());
154 pdpGroup.setVersion(getKey().getVersion());
155 pdpGroup.setDescription(description);
156 pdpGroup.setPdpGroupState(pdpGroupState);
158 pdpGroup.setProperties(properties == null ? null : new LinkedHashMap<>(properties));
160 pdpGroup.setPdpSubgroups(new ArrayList<>(pdpSubGroups.size()));
161 for (JpaPdpSubGroup jpaPdpSubgroup : pdpSubGroups) {
162 pdpGroup.getPdpSubgroups().add(jpaPdpSubgroup.toAuthorative());
169 public void fromAuthorative(@NonNull final PdpGroup pdpGroup) {
170 if (this.key == null || this.getKey().isNullKey()) {
171 this.setKey(new PfConceptKey(pdpGroup.getName(), pdpGroup.getVersion()));
174 this.description = pdpGroup.getDescription();
175 this.pdpGroupState = pdpGroup.getPdpGroupState();
178 (pdpGroup.getProperties() == null ? null : new LinkedHashMap<>(pdpGroup.getProperties()));
180 this.pdpSubGroups = new ArrayList<>();
181 for (PdpSubGroup pdpSubgroup : pdpGroup.getPdpSubgroups()) {
182 JpaPdpSubGroup jpaPdpSubGroup = new JpaPdpSubGroup();
183 jpaPdpSubGroup.setKey(new PfReferenceKey(getKey(), pdpSubgroup.getPdpType()));
184 jpaPdpSubGroup.fromAuthorative(pdpSubgroup);
185 this.pdpSubGroups.add(jpaPdpSubGroup);
190 public List<PfKey> getKeys() {
191 List<PfKey> keyList = getKey().getKeys();
193 for (JpaPdpSubGroup jpaPdpSubgroup : pdpSubGroups) {
194 keyList.addAll(jpaPdpSubgroup.getKeys());
201 public void clean() {
204 description = (description == null ? null : description.trim());
206 if (properties != null) {
207 Map<String, String> cleanedPropertyMap = new LinkedHashMap<>();
208 for (Entry<String, String> propertyEntry : properties.entrySet()) {
209 cleanedPropertyMap.put(propertyEntry.getKey().trim(), propertyEntry.getValue().trim());
211 properties = cleanedPropertyMap;
214 for (JpaPdpSubGroup jpaPdpSubgroup : pdpSubGroups) {
215 jpaPdpSubgroup.clean();
220 public PfValidationResult validate(@NonNull final PfValidationResult resultIn) {
221 PfValidationResult result = resultIn;
223 if (key.isNullKey()) {
224 result.addValidationMessage(
225 new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, "key is a null key"));
228 result = key.validate(result);
230 if (description != null && StringUtils.isBlank(description)) {
231 result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
232 "description may not be blank"));
235 if (pdpGroupState == null) {
236 result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
237 "pdpGroupState may not be null"));
240 if (properties != null) {
241 result = validateProperties(result);
244 if (pdpSubGroups == null) {
245 result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
246 "a PDP group must have a list of PDP subgroups"));
248 for (JpaPdpSubGroup jpaPdpSubgroup : pdpSubGroups) {
249 result = jpaPdpSubgroup.validate(result);
257 * Validate the properties.
259 * @param resultIn the incoming validation results so far
260 * @return the revalidation results including the property validation results
262 private PfValidationResult validateProperties(PfValidationResult resultIn) {
263 PfValidationResult result = resultIn;
265 for (Entry<String, String> propertyEntry : properties.entrySet()) {
266 if (!ParameterValidationUtils.validateStringParameter(propertyEntry.getKey())) {
267 result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
268 "a property key may not be null or blank"));
270 if (!ParameterValidationUtils.validateStringParameter(propertyEntry.getValue())) {
271 result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
272 "a property value may not be null or blank"));
280 public int compareTo(final PfConcept otherConcept) {
281 if (otherConcept == null) {
284 if (this == otherConcept) {
287 if (getClass() != otherConcept.getClass()) {
288 return this.getClass().getName().compareTo(otherConcept.getClass().getName());
291 final JpaPdpGroup other = (JpaPdpGroup) otherConcept;
292 if (!key.equals(other.key)) {
293 return key.compareTo(other.key);
296 int result = ObjectUtils.compare(description, other.description);
301 result = ObjectUtils.compare(pdpGroupState, other.pdpGroupState);
306 result = PfUtils.compareObjects(properties, other.properties);
311 return PfUtils.compareObjects(pdpSubGroups, other.pdpSubGroups);
315 public PfConcept copyTo(@NonNull final PfConcept target) {
316 Assertions.instanceOf(target, JpaPdpGroup.class);
318 final JpaPdpGroup copy = ((JpaPdpGroup) target);
319 copy.setKey(new PfConceptKey(key));
321 copy.setDescription(description);
322 copy.setPdpGroupState(pdpGroupState);
323 copy.setProperties(properties == null ? null : new LinkedHashMap<>(properties));
324 copy.setPdpSubGroups(PfUtils.mapList(pdpSubGroups, JpaPdpSubGroup::new));