Fix issue with GeneratedValue in PfGeneratedIdKey
[policy/models.git] / models-provider / src / main / java / org / onap / policy / models / provider / impl / AbstractPolicyModelsProvider.java
1 /*-
2  * ============LICENSE_START=======================================================
3  *  Copyright (C) 2021-2022 Nordix Foundation.
4  *  Modifications Copyright (C) 2022 Bell Canada. All rights reserved.
5  * ================================================================================
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  *      http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  *
18  * SPDX-License-Identifier: Apache-2.0
19  * ============LICENSE_END=========================================================
20  */
21
22 package org.onap.policy.models.provider.impl;
23
24 import java.util.Collection;
25 import java.util.List;
26 import java.util.Map;
27 import javax.ws.rs.core.Response;
28 import lombok.NonNull;
29 import org.onap.policy.models.base.PfConceptKey;
30 import org.onap.policy.models.base.PfModelException;
31 import org.onap.policy.models.base.PfModelRuntimeException;
32 import org.onap.policy.models.dao.PfDao;
33 import org.onap.policy.models.pdp.concepts.Pdp;
34 import org.onap.policy.models.pdp.concepts.PdpGroup;
35 import org.onap.policy.models.pdp.concepts.PdpGroupFilter;
36 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus;
37 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
38 import org.onap.policy.models.pdp.persistence.provider.PdpProvider;
39 import org.onap.policy.models.provider.PolicyModelsProvider;
40 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
41 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifierOptVersion;
42 import org.onap.policy.models.tosca.authorative.concepts.ToscaEntityFilter;
43 import org.onap.policy.models.tosca.authorative.concepts.ToscaEntityKey;
44 import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate;
45 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
46 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType;
47 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
48 import org.onap.policy.models.tosca.authorative.concepts.ToscaTypedEntityFilter;
49 import org.onap.policy.models.tosca.authorative.provider.AuthorativeToscaProvider;
50
51 public abstract class AbstractPolicyModelsProvider implements PolicyModelsProvider {
52
53     protected abstract PfDao getPfDao();
54
55     @Override
56     public List<ToscaServiceTemplate> getServiceTemplateList(final String name, final String version)
57             throws PfModelException {
58         assertInitialized();
59         return new AuthorativeToscaProvider().getServiceTemplateList(getPfDao(), name, version);
60     }
61
62
63     @Override
64     public List<ToscaServiceTemplate> getFilteredServiceTemplateList(
65             @NonNull ToscaEntityFilter<ToscaServiceTemplate> filter) throws PfModelException {
66         assertInitialized();
67         return new AuthorativeToscaProvider().getFilteredServiceTemplateList(getPfDao(), filter);
68     }
69
70     @Override
71     public ToscaServiceTemplate createServiceTemplate(@NonNull final ToscaServiceTemplate serviceTemplate)
72             throws PfModelException {
73         assertInitialized();
74         return new AuthorativeToscaProvider().createServiceTemplate(getPfDao(), serviceTemplate);
75     }
76
77     @Override
78     public ToscaServiceTemplate updateServiceTemplate(@NonNull final ToscaServiceTemplate serviceTemplate)
79             throws PfModelException {
80         assertInitialized();
81         return new AuthorativeToscaProvider().updateServiceTemplate(getPfDao(), serviceTemplate);
82     }
83
84     @Override
85     public ToscaServiceTemplate deleteServiceTemplate(@NonNull final String name, @NonNull final String version)
86             throws PfModelException {
87         assertInitialized();
88
89         return new AuthorativeToscaProvider().deleteServiceTemplate(getPfDao(), name, version);
90     }
91
92     @Override
93     public ToscaServiceTemplate getPolicyTypes(final String name, final String version) throws PfModelException {
94         assertInitialized();
95         return new AuthorativeToscaProvider().getPolicyTypes(getPfDao(), name, version);
96     }
97
98     @Override
99     public List<ToscaPolicyType> getPolicyTypeList(final String name, final String version) throws PfModelException {
100         assertInitialized();
101         return new AuthorativeToscaProvider().getPolicyTypeList(getPfDao(), name, version);
102     }
103
104     @Override
105     public ToscaServiceTemplate getFilteredPolicyTypes(@NonNull ToscaEntityFilter<ToscaPolicyType> filter)
106             throws PfModelException {
107         assertInitialized();
108         return new AuthorativeToscaProvider().getFilteredPolicyTypes(getPfDao(), filter);
109     }
110
111     @Override
112     public List<ToscaPolicyType> getFilteredPolicyTypeList(@NonNull ToscaEntityFilter<ToscaPolicyType> filter)
113             throws PfModelException {
114         assertInitialized();
115         return new AuthorativeToscaProvider().getFilteredPolicyTypeList(getPfDao(), filter);
116     }
117
118     @Override
119     public ToscaServiceTemplate createPolicyTypes(@NonNull final ToscaServiceTemplate serviceTemplate)
120             throws PfModelException {
121         assertInitialized();
122         return new AuthorativeToscaProvider().createPolicyTypes(getPfDao(), serviceTemplate);
123     }
124
125     @Override
126     public ToscaServiceTemplate updatePolicyTypes(@NonNull final ToscaServiceTemplate serviceTemplate)
127             throws PfModelException {
128         assertInitialized();
129         return new AuthorativeToscaProvider().updatePolicyTypes(getPfDao(), serviceTemplate);
130     }
131
132     @Override
133     public ToscaServiceTemplate deletePolicyType(@NonNull final String name, @NonNull final String version)
134             throws PfModelException {
135         assertInitialized();
136
137         var policyTypeIdentifier = new ToscaConceptIdentifier(name, version);
138         assertPolicyTypeNotSupportedInPdpGroup(policyTypeIdentifier);
139
140         return new AuthorativeToscaProvider().deletePolicyType(getPfDao(), name, version);
141     }
142
143     @Override
144     public ToscaServiceTemplate getPolicies(final String name, final String version) throws PfModelException {
145         assertInitialized();
146         return new AuthorativeToscaProvider().getPolicies(getPfDao(), name, version);
147     }
148
149     @Override
150     public List<ToscaPolicy> getPolicyList(final String name, final String version) throws PfModelException {
151         assertInitialized();
152         return new AuthorativeToscaProvider().getPolicyList(getPfDao(), name, version);
153     }
154
155     @Override
156     public ToscaServiceTemplate getFilteredPolicies(@NonNull ToscaTypedEntityFilter<ToscaPolicy> filter)
157             throws PfModelException {
158         assertInitialized();
159         return new AuthorativeToscaProvider().getFilteredPolicies(getPfDao(), filter);
160     }
161
162     @Override
163     public List<ToscaPolicy> getFilteredPolicyList(@NonNull ToscaTypedEntityFilter<ToscaPolicy> filter)
164             throws PfModelException {
165         assertInitialized();
166         return new AuthorativeToscaProvider().getFilteredPolicyList(getPfDao(), filter);
167     }
168
169     @Override
170     public ToscaServiceTemplate createPolicies(@NonNull final ToscaServiceTemplate serviceTemplate)
171             throws PfModelException {
172         assertInitialized();
173         return new AuthorativeToscaProvider().createPolicies(getPfDao(), serviceTemplate);
174     }
175
176     @Override
177     public ToscaServiceTemplate updatePolicies(@NonNull final ToscaServiceTemplate serviceTemplate)
178             throws PfModelException {
179         assertInitialized();
180         return new AuthorativeToscaProvider().updatePolicies(getPfDao(), serviceTemplate);
181     }
182
183     @Override
184     public ToscaServiceTemplate deletePolicy(@NonNull final String name, @NonNull final String version)
185             throws PfModelException {
186         assertInitialized();
187
188         var policyIdentifier = new ToscaConceptIdentifier(name, version);
189         assertPolicyNotDeployedInPdpGroup(policyIdentifier);
190
191         return new AuthorativeToscaProvider().deletePolicy(getPfDao(), name, version);
192     }
193
194     @Override
195     public ToscaServiceTemplate createToscaNodeTemplates(@NonNull final ToscaServiceTemplate serviceTemplate)
196         throws PfModelException {
197         assertInitialized();
198         return new AuthorativeToscaProvider().createToscaNodeTemplates(getPfDao(), serviceTemplate);
199     }
200
201     @Override
202     public ToscaServiceTemplate updateToscaNodeTemplates(@NonNull final ToscaServiceTemplate serviceTemplate)
203         throws PfModelRuntimeException, PfModelException {
204         assertInitialized();
205         return new AuthorativeToscaProvider().updateToscaNodeTemplates(getPfDao(), serviceTemplate);
206     }
207
208     @Override
209     public ToscaServiceTemplate deleteToscaNodeTemplate(@NonNull final String name, @NonNull final String version)
210         throws PfModelException {
211         assertInitialized();
212         return new AuthorativeToscaProvider().deleteToscaNodeTemplate(getPfDao(), name, version);
213     }
214
215     @Override
216     public List<Map<ToscaEntityKey, Map<String, Object>>> getNodeTemplateMetadataSets(final String name,
217                                                                                       final String version)
218         throws PfModelException {
219         assertInitialized();
220         return new AuthorativeToscaProvider().getNodeTemplateMetadataSet(getPfDao(), name, version);
221     }
222
223     @Override
224     public List<Map<PfConceptKey, ToscaNodeTemplate>> getToscaNodeTemplate(final String name,
225                                                                            final String version)
226         throws PfModelException {
227         assertInitialized();
228         return new AuthorativeToscaProvider().getToscaNodeTemplate(getPfDao(), name, version);
229     }
230
231
232
233     @Override
234     public List<PdpGroup> getPdpGroups(final String name) throws PfModelException {
235         assertInitialized();
236         return new PdpProvider().getPdpGroups(getPfDao(), name);
237     }
238
239     @Override
240     public List<PdpGroup> getFilteredPdpGroups(@NonNull PdpGroupFilter filter) throws PfModelException {
241         assertInitialized();
242         return new PdpProvider().getFilteredPdpGroups(getPfDao(), filter);
243     }
244
245     @Override
246     public List<PdpGroup> createPdpGroups(@NonNull final List<PdpGroup> pdpGroups) throws PfModelException {
247         assertInitialized();
248         return new PdpProvider().createPdpGroups(getPfDao(), pdpGroups);
249     }
250
251     @Override
252     public List<PdpGroup> updatePdpGroups(@NonNull final List<PdpGroup> pdpGroups) throws PfModelException {
253         assertInitialized();
254         return new PdpProvider().updatePdpGroups(getPfDao(), pdpGroups);
255     }
256
257     @Override
258     public void updatePdpSubGroup(@NonNull final String pdpGroupName, @NonNull final PdpSubGroup pdpSubGroup)
259             throws PfModelException {
260         assertInitialized();
261         new PdpProvider().updatePdpSubGroup(getPfDao(), pdpGroupName, pdpSubGroup);
262     }
263
264     @Override
265     public void updatePdp(@NonNull String pdpGroupName, @NonNull String pdpSubGroup, @NonNull Pdp pdp)
266             throws PfModelException {
267         new PdpProvider().updatePdp(getPfDao(), pdpGroupName, pdpSubGroup, pdp);
268     }
269
270     @Override
271     public PdpGroup deletePdpGroup(@NonNull final String name) throws PfModelException {
272         assertInitialized();
273         return new PdpProvider().deletePdpGroup(getPfDao(), name);
274     }
275
276     @Override
277     public List<PdpPolicyStatus> getAllPolicyStatus() throws PfModelException {
278         assertInitialized();
279         return new PdpProvider().getAllPolicyStatus(getPfDao());
280     }
281
282     @Override
283     public List<PdpPolicyStatus> getAllPolicyStatus(@NonNull ToscaConceptIdentifierOptVersion policy)
284             throws PfModelException {
285         assertInitialized();
286         return new PdpProvider().getAllPolicyStatus(getPfDao(), policy);
287     }
288
289     @Override
290     public List<PdpPolicyStatus> getGroupPolicyStatus(@NonNull String groupName) throws PfModelException {
291         assertInitialized();
292         return new PdpProvider().getGroupPolicyStatus(getPfDao(), groupName);
293     }
294
295     @Override
296     public void cudPolicyStatus(Collection<PdpPolicyStatus> createObjs, Collection<PdpPolicyStatus> updateObjs,
297             Collection<PdpPolicyStatus> deleteObjs) {
298         assertInitialized();
299         new PdpProvider().cudPolicyStatus(getPfDao(), createObjs, updateObjs, deleteObjs);
300     }
301
302     /**
303      * Check if the model provider is initialized.
304      */
305     private void assertInitialized() {
306         if (getPfDao() == null) {
307             var errorMessage = "policy models provider is not initilaized";
308             throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, errorMessage);
309         }
310     }
311
312     /**
313      * Assert that the policy type is not supported in any PDP group.
314      *
315      * @param policyTypeIdentifier the policy type identifier
316      * @throws PfModelException if the policy type is supported in a PDP group
317      */
318     private void assertPolicyTypeNotSupportedInPdpGroup(ToscaConceptIdentifier policyTypeIdentifier)
319             throws PfModelException {
320         for (PdpGroup pdpGroup : getPdpGroups(null)) {
321             for (PdpSubGroup pdpSubGroup : pdpGroup.getPdpSubgroups()) {
322                 if (pdpSubGroup.getSupportedPolicyTypes().contains(policyTypeIdentifier)) {
323                     throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE,
324                             "policy type is in use, it is referenced in PDP group " + pdpGroup.getName() + " subgroup "
325                                     + pdpSubGroup.getPdpType());
326                 }
327             }
328         }
329     }
330
331     /**
332      * Assert that the policy is not deployed in a PDP group.
333      *
334      * @param policyIdentifier the identifier of the policy
335      * @throws PfModelException thrown if the policy is deployed in a PDP group
336      */
337     private void assertPolicyNotDeployedInPdpGroup(final ToscaConceptIdentifier policyIdentifier)
338             throws PfModelException {
339         for (PdpGroup pdpGroup : getPdpGroups(null)) {
340             for (PdpSubGroup pdpSubGroup : pdpGroup.getPdpSubgroups()) {
341                 if (pdpSubGroup.getPolicies().contains(policyIdentifier)) {
342                     throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE,
343                             "policy is in use, it is deployed in PDP group " + pdpGroup.getName() + " subgroup "
344                                     + pdpSubGroup.getPdpType());
345                 }
346             }
347         }
348     }
349
350 }