2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2022 Bell Canada. All rights reserved.
4 * Modifications Copyright (C) 2022 Nordix Foundation.
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
10 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 * SPDX-License-Identifier: Apache-2.0
19 * ============LICENSE_END=========================================================
22 package org.onap.policy.api.main.service;
24 import java.util.ArrayList;
25 import java.util.List;
26 import java.util.Optional;
27 import javax.annotation.Nonnull;
28 import javax.ws.rs.core.Response;
29 import lombok.NonNull;
30 import lombok.RequiredArgsConstructor;
31 import org.apache.commons.collections4.CollectionUtils;
32 import org.onap.policy.api.main.repository.ToscaServiceTemplateRepository;
33 import org.onap.policy.api.main.rest.PolicyFetchMode;
34 import org.onap.policy.common.parameters.BeanValidationResult;
35 import org.onap.policy.models.base.PfConceptKey;
36 import org.onap.policy.models.base.PfModelException;
37 import org.onap.policy.models.base.PfModelRuntimeException;
38 import org.onap.policy.models.tosca.authorative.concepts.ToscaEntityFilter;
39 import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate;
40 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
41 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType;
42 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
43 import org.onap.policy.models.tosca.authorative.concepts.ToscaTypedEntityFilter;
44 import org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTemplate;
45 import org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTemplates;
46 import org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTypes;
47 import org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicies;
48 import org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicyTypes;
49 import org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate;
50 import org.onap.policy.models.tosca.simple.concepts.JpaToscaTopologyTemplate;
51 import org.onap.policy.models.tosca.simple.provider.SimpleToscaProvider;
52 import org.onap.policy.models.tosca.utils.ToscaServiceTemplateUtils;
53 import org.onap.policy.models.tosca.utils.ToscaUtils;
54 import org.slf4j.Logger;
55 import org.slf4j.LoggerFactory;
56 import org.springframework.stereotype.Service;
57 import org.springframework.transaction.annotation.Transactional;
61 @RequiredArgsConstructor
62 public class ToscaServiceTemplateService {
64 private static final Logger LOGGER = LoggerFactory.getLogger(ToscaServiceTemplateService.class);
66 // Recurring string constants
67 private static final String POLICY_TYPE = "policy type ";
68 private static final String NOT_FOUND = " not found";
69 public static final String SERVICE_TEMPLATE_NOT_FOUND_MSG = "service template not found in database";
70 public static final String DO_NOT_EXIST_MSG = " do not exist";
72 private final ToscaServiceTemplateRepository toscaServiceTemplateRepository;
73 private final NodeTemplateService nodeTemplateService;
74 private final PdpGroupService pdpGroupService;
75 private final PolicyTypeService policyTypeService;
76 private final PolicyService policyService;
79 * Retrieves a list of policy types matching specified policy type name and version.
81 * @param policyTypeName the name of policy type
82 * @param policyTypeVersion the version of policy type
83 * @return the ToscaServiceTemplate object
85 public ToscaServiceTemplate fetchPolicyTypes(final String policyTypeName, final String policyTypeVersion)
86 throws PfModelException {
87 final var policyTypeFilter =
88 ToscaEntityFilter.<ToscaPolicyType>builder().name(policyTypeName).version(policyTypeVersion).build();
89 return getFilteredPolicyTypes(policyTypeFilter);
93 * Retrieves a list of policy types with the latest versions.
95 * @param policyTypeName the name of policy type
96 * @return the ToscaServiceTemplate object
98 public ToscaServiceTemplate fetchLatestPolicyTypes(final String policyTypeName) throws PfModelException {
99 final var policyTypeFilter = ToscaEntityFilter.<ToscaPolicyType>builder()
100 .name(policyTypeName).version(ToscaEntityFilter.LATEST_VERSION).build();
101 return getFilteredPolicyTypes(policyTypeFilter);
105 * Creates a new policy type.
107 * @param body the entity body of policy type
108 * @return the TOSCA service template containing the created policy types
109 * @throws PfModelRuntimeException on errors creating policy types
111 public ToscaServiceTemplate createPolicyType(@NonNull final ToscaServiceTemplate body)
112 throws PfModelRuntimeException {
113 final var incomingServiceTemplate = new JpaToscaServiceTemplate(body);
114 LOGGER.debug("->createPolicyType: serviceTemplate={}", incomingServiceTemplate);
116 // assert incoming body contains policyTypes
117 ToscaUtils.assertPolicyTypesExist(incomingServiceTemplate);
119 // append the incoming fragment to the DB TOSCA service template
120 var dbServiceTemplateOpt = getDefaultJpaToscaServiceTemplateOpt();
121 JpaToscaServiceTemplate serviceTemplateToWrite;
122 if (dbServiceTemplateOpt.isEmpty()) {
123 serviceTemplateToWrite = incomingServiceTemplate;
125 serviceTemplateToWrite =
126 ToscaServiceTemplateUtils.addFragment(dbServiceTemplateOpt.get(), incomingServiceTemplate);
129 final var result = serviceTemplateToWrite.validate("service template");
130 if (!result.isValid()) {
131 throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE, result.getResult());
133 toscaServiceTemplateRepository.save(serviceTemplateToWrite);
134 LOGGER.debug("<-createPolicyType: writtenServiceTemplate={}", serviceTemplateToWrite);
140 * Delete the policy type matching specified policy type name and version.
142 * @param policyTypeName the name of policy type
143 * @param policyTypeVersion the version of policy type, if the version of the key is null,
144 * all versions of the policy type are deleted.
145 * @return the TOSCA service template containing the policy types that were deleted
146 * @throws PfModelRuntimeException on errors deleting policy types
148 public ToscaServiceTemplate deletePolicyType(final String policyTypeName, final String policyTypeVersion)
149 throws PfModelRuntimeException {
150 final var policyTypeKey = new PfConceptKey(policyTypeName, policyTypeVersion);
151 LOGGER.debug("->deletePolicyType: name={}, version={}", policyTypeName, policyTypeVersion);
153 // terminate deletion if supported in a PdpGroup
154 pdpGroupService.assertPolicyTypeNotSupportedInPdpGroup(policyTypeName, policyTypeVersion);
156 final var serviceTemplate = getDefaultJpaToscaServiceTemplate();
158 // terminate deletion if not found
159 if (!ToscaUtils.doPolicyTypesExist(serviceTemplate)) {
160 throw new PfModelRuntimeException(Response.Status.NOT_FOUND, "no policy types found");
163 final var policyTypeForDeletion = serviceTemplate.getPolicyTypes().get(policyTypeKey);
164 if (policyTypeForDeletion == null) {
165 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
166 POLICY_TYPE + policyTypeKey.getId() + NOT_FOUND);
169 final var result = new BeanValidationResult("policy types", serviceTemplate);
171 for (final var policyType : serviceTemplate.getPolicyTypes().getAll(null)) {
172 final var ancestorList = ToscaUtils
173 .getEntityTypeAncestors(serviceTemplate.getPolicyTypes(), policyType, result);
174 // terminate deletion if referenced by another via derived_from property
175 if (ancestorList.contains(policyTypeForDeletion)) {
176 throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE, POLICY_TYPE + policyTypeKey.getId()
177 + " is in use, it is referenced in policy type " + policyType.getId());
180 if (ToscaUtils.doPoliciesExist(serviceTemplate)) {
181 for (final var policy : serviceTemplate.getTopologyTemplate().getPolicies().getAll(null)) {
182 // terminate deletion if referenced by a policy
183 if (policyTypeKey.equals(policy.getType())) {
184 throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE, POLICY_TYPE
185 + policyTypeKey.getId() + " is in use, it is referenced in policy " + policy.getId());
190 // remove policyType from service template and write to DB
191 serviceTemplate.getPolicyTypes().getConceptMap().remove(policyTypeKey);
192 toscaServiceTemplateRepository.save(serviceTemplate);
194 // remove the entry from the Policy table
195 policyTypeService.deletePolicyType(policyTypeKey);
197 // prepare return service template object
198 var deletedServiceTemplate = new JpaToscaServiceTemplate();
199 deletedServiceTemplate.setPolicyTypes(new JpaToscaPolicyTypes());
200 deletedServiceTemplate.getPolicyTypes().getConceptMap().put(policyTypeKey, policyTypeForDeletion);
202 LOGGER.debug("<-deletePolicyType: key={}, serviceTemplate={}", policyTypeKey, deletedServiceTemplate);
203 return deletedServiceTemplate.toAuthorative();
207 * Retrieves a list of policies matching specified name and version of both policy type and policy.
209 * @param policyTypeName the name of policy type
210 * @param policyTypeVersion the version of policy type
211 * @param policyName the name of policy
212 * @param policyVersion the version of policy
213 * @param mode the fetch mode for policies
214 * @return the ToscaServiceTemplate object with the policies found
215 * @throws PfModelException on errors getting the policy
217 public ToscaServiceTemplate fetchPolicies(final String policyTypeName, final String policyTypeVersion,
218 final String policyName, final String policyVersion, final PolicyFetchMode mode) throws PfModelException {
219 return getFilteredPolicies(policyTypeName, policyTypeVersion, policyName, policyVersion, mode);
223 * Retrieves a list of policies with the latest versions that match specified policy type id and version.
225 * @param policyTypeName the name of policy type
226 * @param policyTypeVersion the version of policy type
227 * @param policyName the name of the policy
228 * @param mode the fetch mode for policies
229 * @return the ToscaServiceTemplate object with the policies found
230 * @throws PfModelException on errors getting the policy
232 public ToscaServiceTemplate fetchLatestPolicies(final String policyTypeName, final String policyTypeVersion,
233 final String policyName, final PolicyFetchMode mode) throws PfModelException {
234 return getFilteredPolicies(policyTypeName, policyTypeVersion, policyName, ToscaTypedEntityFilter.LATEST_VERSION,
239 * Creates one or more new policies for the same policy type name and version.
241 * @param policyTypeName the name of policy type
242 * @param policyTypeVersion the version of policy type
243 * @param body the entity body of polic(ies)
244 * @return the ToscaServiceTemplate object containing the policy types that were created
245 * @throws PfModelRuntimeException on errors creating the policy
247 public ToscaServiceTemplate createPolicy(final String policyTypeName, final String policyTypeVersion,
248 final ToscaServiceTemplate body) throws PfModelRuntimeException {
249 return createPolicies(body);
253 * Creates one or more new policies.
255 * @param body the entity body of policy
256 * @return the ToscaServiceTemplate object containing the policy types that were created
257 * @throws PfModelRuntimeException on errors creating the policy
259 public ToscaServiceTemplate createPolicies(final ToscaServiceTemplate body) throws PfModelRuntimeException {
260 final var incomingServiceTemplate = new JpaToscaServiceTemplate(body);
262 // assert incoming body contains policies
263 ToscaUtils.assertPoliciesExist(incomingServiceTemplate);
265 // append the incoming fragment to the DB TOSCA service template
266 var dbServiceTemplateOpt = getDefaultJpaToscaServiceTemplateOpt();
267 JpaToscaServiceTemplate serviceTemplateToWrite;
268 if (dbServiceTemplateOpt.isEmpty()) {
269 serviceTemplateToWrite = incomingServiceTemplate;
271 serviceTemplateToWrite =
272 ToscaServiceTemplateUtils.addFragment(dbServiceTemplateOpt.get(), incomingServiceTemplate);
275 final var result = serviceTemplateToWrite.validate("Policies CRUD service template.");
276 if (!result.isValid()) {
277 throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE, result.getResult());
280 toscaServiceTemplateRepository.save(serviceTemplateToWrite);
282 LOGGER.debug("<-appendServiceTemplateFragment: returnServiceTemplate={}", serviceTemplateToWrite);
287 * Deletes the policy matching specified name and version of both policy type and policy.
289 * @param policyTypeName the name of policy type
290 * @param policyTypeVersion the version of policy type
291 * @param policyName the name of policy
292 * @param policyVersion the version of policy
293 * @return the ToscaServiceTemplate object containing the policies that were deleted
294 * @throws PfModelRuntimeException on errors deleting the policy
296 public ToscaServiceTemplate deletePolicy(final String policyTypeName, final String policyTypeVersion,
297 final String policyName, final String policyVersion) throws PfModelRuntimeException {
298 final var policyKey = new PfConceptKey(policyName, policyVersion);
299 LOGGER.debug("->deletePolicy: name={}, version={}", policyName, policyVersion);
301 // terminate if deployed in a PdpGroup
302 pdpGroupService.assertPolicyNotDeployedInPdpGroup(policyName, policyVersion);
304 final var serviceTemplate = getDefaultJpaToscaServiceTemplate();
306 // terminate deletion if not found
307 if (!ToscaUtils.doPoliciesExist(serviceTemplate)) {
308 throw new PfModelRuntimeException(Response.Status.NOT_FOUND, "no policies found");
311 final var policyForDeletion = serviceTemplate.getTopologyTemplate().getPolicies().get(policyKey);
312 if (policyForDeletion == null) {
313 throw new PfModelRuntimeException(Response.Status.NOT_FOUND, "policy " + policyKey.getId() + NOT_FOUND);
316 // remove policy from service template and write to DB
317 serviceTemplate.getTopologyTemplate().getPolicies().getConceptMap().remove(policyKey);
318 toscaServiceTemplateRepository.save(serviceTemplate);
320 // remove the entry from the Policy table
321 policyService.deletePolicy(policyKey);
323 // prepare return service template object
324 var deletedServiceTemplate = new JpaToscaServiceTemplate();
325 deletedServiceTemplate.setTopologyTemplate(new JpaToscaTopologyTemplate());
326 deletedServiceTemplate.getTopologyTemplate().setPolicies(new JpaToscaPolicies());
327 deletedServiceTemplate.getTopologyTemplate().getPolicies().getConceptMap().put(policyKey, policyForDeletion);
329 LOGGER.debug("<-deletePolicy: key={}, serviceTemplate={}", policyKey, deletedServiceTemplate);
330 return deletedServiceTemplate.toAuthorative();
334 * Retrieves TOSCA service template with the specified version of the policy type.
336 * @param policyTypeFilter the policy type filter containing name and version of the policy type
337 * @return the TOSCA service template containing the specified version of the policy type
338 * @throws PfModelException on errors getting the policy type
340 public ToscaServiceTemplate getFilteredPolicyTypes(final ToscaEntityFilter<ToscaPolicyType> policyTypeFilter)
341 throws PfModelException {
342 final var dbServiceTemplate = getDefaultJpaToscaServiceTemplate();
343 LOGGER.debug("->getFilteredPolicyTypes: filter={}, serviceTemplate={}", policyTypeFilter, dbServiceTemplate);
345 // validate that policyTypes exist in db
346 if (!ToscaUtils.doPolicyTypesExist(dbServiceTemplate)) {
347 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
348 "policy types for filter " + policyTypeFilter + DO_NOT_EXIST_MSG);
351 var version = ToscaTypedEntityFilter.LATEST_VERSION
352 .equals(policyTypeFilter.getVersion()) ? null : policyTypeFilter.getVersion();
353 // fetch all polices and filter by policyType, policy name and version
354 final var serviceTemplate = new SimpleToscaProvider()
355 .getCascadedPolicyTypes(dbServiceTemplate, policyTypeFilter.getName(), version);
356 var simpleToscaProvider = new SimpleToscaProvider();
358 List<ToscaPolicyType> filteredPolicyTypes = serviceTemplate.getPolicyTypes().toAuthorativeList();
359 filteredPolicyTypes = policyTypeFilter.filter(filteredPolicyTypes);
361 // validate that filtered policyTypes exist
362 if (CollectionUtils.isEmpty(filteredPolicyTypes)) {
363 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
364 "policy types for filter " + policyTypeFilter + DO_NOT_EXIST_MSG);
367 // prepare return service template object
368 var returnServiceTemplate = new JpaToscaServiceTemplate();
369 for (var policyType : filteredPolicyTypes) {
370 final var cascadedServiceTemplate = simpleToscaProvider
371 .getCascadedPolicyTypes(dbServiceTemplate, policyType.getName(), policyType.getVersion());
372 returnServiceTemplate =
373 ToscaServiceTemplateUtils.addFragment(returnServiceTemplate, cascadedServiceTemplate);
376 LOGGER.debug("<-getFilteredPolicyTypes: filter={}, serviceTemplate={}", policyTypeFilter,
377 returnServiceTemplate);
378 return returnServiceTemplate.toAuthorative();
383 * Retrieves TOSCA service template with the specified version of the policy.
385 * @param policyName the name of the policy
386 * @param policyVersion the version of the policy
387 * @param mode the fetch mode for policies
388 * @return the TOSCA service template containing the specified version of the policy
389 * @throws PfModelException on errors getting the policy
391 private ToscaServiceTemplate getFilteredPolicies(final String policyTypeName, final String policyTypeVersion,
392 final String policyName, final String policyVersion, final PolicyFetchMode mode) throws PfModelException {
393 final var policyFilter = ToscaTypedEntityFilter.<ToscaPolicy>builder()
394 .name(policyName).version(policyVersion).type(policyTypeName).typeVersion(policyTypeVersion).build();
395 final var dbServiceTemplate = getDefaultJpaToscaServiceTemplate();
396 LOGGER.debug("<-getFilteredPolicies: filter={}, serviceTemplate={}", policyFilter, dbServiceTemplate);
398 // validate that policies exist in db
399 if (!ToscaUtils.doPolicyTypesExist(dbServiceTemplate)) {
400 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
401 "policies for filter " + policyFilter + DO_NOT_EXIST_MSG);
405 ToscaTypedEntityFilter.LATEST_VERSION.equals(policyFilter.getVersion()) ? null : policyFilter.getVersion();
407 // fetch all polices and filter by policyType, policy name and version
408 final var simpleToscaProvider = new SimpleToscaProvider();
409 final var serviceTemplate =
410 simpleToscaProvider.getCascadedPolicies(dbServiceTemplate, policyFilter.getName(), version);
412 var filteredPolicies = serviceTemplate.getTopologyTemplate()
413 .getPolicies().toAuthorativeList();
414 filteredPolicies = policyFilter.filter(filteredPolicies);
416 // validate that filtered policies exist
417 if (CollectionUtils.isEmpty(filteredPolicies)) {
418 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
419 "policies for filter " + policyFilter + DO_NOT_EXIST_MSG);
422 // prepare return service template object
423 var returnServiceTemplate = new JpaToscaServiceTemplate();
424 for (var policy : filteredPolicies) {
425 final var cascadedServiceTemplate = simpleToscaProvider
426 .getCascadedPolicies(dbServiceTemplate, policy.getName(), policy.getVersion());
427 returnServiceTemplate =
428 ToscaServiceTemplateUtils.addFragment(returnServiceTemplate, cascadedServiceTemplate);
431 if (mode == null || PolicyFetchMode.BARE.equals(mode)) {
432 returnServiceTemplate.setPolicyTypes(null);
433 returnServiceTemplate.setDataTypes(null);
435 LOGGER.debug("<-getFilteredPolicies: filter={}, , serviceTemplate={}", policyFilter, returnServiceTemplate);
436 return returnServiceTemplate.toAuthorative();
440 * Write a node template to the database.
442 * @param serviceTemplate the service template to be written
443 * @return the service template created by this method
444 * @throws PfModelException on errors writing the metadataSets
446 public ToscaServiceTemplate createToscaNodeTemplates(@NonNull final ToscaServiceTemplate serviceTemplate)
447 throws PfModelException {
449 LOGGER.debug("->write: tosca nodeTemplates={}", serviceTemplate);
450 final var incomingServiceTemplate = new JpaToscaServiceTemplate(serviceTemplate);
452 ToscaUtils.assertNodeTemplatesExist(incomingServiceTemplate);
454 Optional<JpaToscaNodeTypes> nodeTypes = Optional.ofNullable(incomingServiceTemplate.getNodeTypes());
455 for (JpaToscaNodeTemplate nodeTemplate : incomingServiceTemplate.getTopologyTemplate().getNodeTemplates()
457 // verify node types in the db if mismatch/empty entities in the template
458 if (! (nodeTypes.isPresent() && nodeTypes.get().getKeys().contains(nodeTemplate.getType()))) {
459 nodeTemplateService.verifyNodeTypeInDbTemplate(nodeTemplate);
462 // append the incoming fragment to the DB TOSCA service template
463 final var serviceTemplateToWrite =
464 ToscaServiceTemplateUtils.addFragment(getDefaultJpaToscaServiceTemplate(), incomingServiceTemplate);
466 final var result = serviceTemplateToWrite.validate("service template.");
467 if (!result.isValid()) {
468 throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE, result.getResult());
470 toscaServiceTemplateRepository.save(serviceTemplateToWrite);
471 LOGGER.debug("<-createdToscaNodeTemplates: writtenServiceTemplate={}", serviceTemplateToWrite);
473 return serviceTemplate;
477 * Update tosca node template.
479 * @param serviceTemplate the service template containing the definitions of the node templates to be updated.
480 * @return the TOSCA service template containing the node templates that were updated
481 * @throws PfModelRuntimeException on errors updating node templates
483 public ToscaServiceTemplate updateToscaNodeTemplates(@NonNull final ToscaServiceTemplate serviceTemplate)
484 throws PfModelException {
485 LOGGER.debug("->updateToscaNodeTemplates: serviceTemplate={}", serviceTemplate);
486 final var incomingServiceTemplate = new JpaToscaServiceTemplate(serviceTemplate);
488 ToscaUtils.assertNodeTemplatesExist(incomingServiceTemplate);
489 nodeTemplateService.updateToscaNodeTemplates(incomingServiceTemplate);
491 LOGGER.debug("<-updatedToscaNodeTemplates: serviceTemplate={}", serviceTemplate);
492 return incomingServiceTemplate.toAuthorative();
497 * Delete a tosca node template.
499 * @param name the name of node template
500 * @param version the version of node template
501 * @return the TOSCA service template containing the node template that were deleted
502 * @throws PfModelException on errors deleting node templates
504 public ToscaServiceTemplate deleteToscaNodeTemplate(@NonNull final String name, @Nonnull final String version)
505 throws PfModelException {
506 LOGGER.debug("->deleteToscaNodeTemplate: name={}, version={}", name, version);
508 JpaToscaServiceTemplate dbServiceTemplate = getDefaultJpaToscaServiceTemplate();
509 final var nodeTemplateKey = new PfConceptKey(name, version);
511 if (!ToscaUtils.doNodeTemplatesExist(dbServiceTemplate)) {
512 throw new PfModelRuntimeException(Response.Status.NOT_FOUND, "no node templates found");
514 JpaToscaNodeTemplate nodeTemplate4Deletion = dbServiceTemplate.getTopologyTemplate().getNodeTemplates()
515 .get(new PfConceptKey(name, version));
516 if (nodeTemplate4Deletion == null) {
517 throw new PfModelRuntimeException(Response.Status.NOT_FOUND, "node template " + name + ":" + version
520 //Verify if the node template is referenced in the metadata of created policies
521 nodeTemplateService.assertNodeTemplateNotUsedInPolicy(name, version, dbServiceTemplate);
523 dbServiceTemplate.getTopologyTemplate().getNodeTemplates().getConceptMap().remove(nodeTemplateKey);
524 toscaServiceTemplateRepository.save(dbServiceTemplate);
526 // remove the entry from the tosca node template table
527 nodeTemplateService.deleteNodeTemplate(nodeTemplateKey);
529 // prepare the return service template
530 var deletedServiceTemplate = new JpaToscaServiceTemplate();
531 deletedServiceTemplate.setTopologyTemplate(new JpaToscaTopologyTemplate());
532 deletedServiceTemplate.getTopologyTemplate().setNodeTemplates(new JpaToscaNodeTemplates());
533 deletedServiceTemplate.getTopologyTemplate().getNodeTemplates().getConceptMap()
534 .put(nodeTemplateKey, nodeTemplate4Deletion);
536 LOGGER.debug("<-deleteToscaNodeTemplate: key={}, serviceTemplate={}", nodeTemplateKey, deletedServiceTemplate);
537 return deletedServiceTemplate.toAuthorative();
542 * Get tosca node templates.
544 * @param name the name of the node template to get, set to null to get all node templates
545 * @param version the version of the node template to get, set to null to get all versions
546 * @return the node templates with the specified key
547 * @throws PfModelException on errors getting node templates
549 public List<ToscaNodeTemplate> fetchToscaNodeTemplates(final String name, final String version)
550 throws PfModelException {
551 LOGGER.debug("->getNodeTemplate: name={}, version={}", name, version);
552 List<ToscaNodeTemplate> nodeTemplates = new ArrayList<>();
553 var jpaNodeTemplates = new JpaToscaNodeTemplates();
555 var dbServiceTemplate = getDefaultJpaToscaServiceTemplate();
556 //Return empty if no nodeTemplates present in db
557 if (!ToscaUtils.doNodeTemplatesExist(dbServiceTemplate)) {
558 return nodeTemplates;
560 jpaNodeTemplates = dbServiceTemplate.getTopologyTemplate().getNodeTemplates();
562 //Filter specific nodeTemplates
563 if (name != null && version != null) {
564 var filterKey = new PfConceptKey(name, version);
565 jpaNodeTemplates.getConceptMap().entrySet().removeIf(entity -> !entity.getKey().equals(filterKey));
567 jpaNodeTemplates.getConceptMap().forEach((key, value) -> nodeTemplates.add(value.toAuthorative()));
568 LOGGER.debug("<-getNodeTemplateMetadataSet: name={}, version={}, nodeTemplates={}", name, version,
571 return nodeTemplates;
576 * Get Service Template.
578 * @return the Service Template read from the database
579 * @throws PfModelRuntimeException if service template if not found in database.
581 public JpaToscaServiceTemplate getDefaultJpaToscaServiceTemplate() throws PfModelRuntimeException {
582 final var defaultServiceTemplateOpt = getDefaultJpaToscaServiceTemplateOpt();
583 if (defaultServiceTemplateOpt.isEmpty()) {
584 throw new PfModelRuntimeException(Response.Status.NOT_FOUND, SERVICE_TEMPLATE_NOT_FOUND_MSG);
586 LOGGER.debug("<-getDefaultJpaToscaServiceTemplate: serviceTemplate={}", defaultServiceTemplateOpt.get());
587 return defaultServiceTemplateOpt.get();
591 * Get Service Template Optional object.
593 * @return the Optional object for Service Template read from the database
595 private Optional<JpaToscaServiceTemplate> getDefaultJpaToscaServiceTemplateOpt() {
596 return toscaServiceTemplateRepository
597 .findById(new PfConceptKey(JpaToscaServiceTemplate.DEFAULT_NAME, JpaToscaServiceTemplate.DEFAULT_VERSION));