models-tosca/src/main/java/org/onap/policy/models/tosca/authorative/provider/AuthorativeToscaProvider.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019-2021 Nordix Foundation.
   4  *  Modifications Copyright (C) 2019 AT&T Intellectual Property. 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.tosca.authorative.provider;
  23
  24 import java.util.ArrayList;
  25 import java.util.Collections;
  26 import java.util.List;
  27 import java.util.Map;
  28 import javax.ws.rs.core.Response;
  29 import javax.ws.rs.core.Response.Status;
  30 import lombok.NonNull;
  31 import org.apache.commons.collections4.CollectionUtils;
  32 import org.onap.policy.models.base.PfConceptKey;
  33 import org.onap.policy.models.base.PfModelException;
  34 import org.onap.policy.models.base.PfModelRuntimeException;
  35 import org.onap.policy.models.dao.PfDao;
  36 import org.onap.policy.models.tosca.authorative.concepts.ToscaEntity;
  37 import org.onap.policy.models.tosca.authorative.concepts.ToscaEntityFilter;
  38 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
  39 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType;
  40 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  41 import org.onap.policy.models.tosca.authorative.concepts.ToscaTypedEntityFilter;
  42 import org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate;
  43 import org.onap.policy.models.tosca.simple.provider.SimpleToscaProvider;
  44 import org.onap.policy.models.tosca.utils.ToscaServiceTemplateUtils;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 /**
  49  * This class provides the provision of information on TOSCA concepts in the database to callers.
  50  *
  51  * @author Liam Fallon (liam.fallon@est.tech)
  52  */
  53 public class AuthorativeToscaProvider {
  54     private static final Logger LOGGER = LoggerFactory.getLogger(AuthorativeToscaProvider.class);
  55
  56     // TODO: In next release this locking mechanism should be removed and replaced with proper session handling
  57     private static final Object providerLockObject = "providerLockObject";
  58
  59     /**
  60      * Get service templates.
  61      *
  62      * @param dao the DAO to use to access the database
  63      * @param name the name of the service template to get.
  64      * @param version the version of the service template to get.
  65      * @return the service templates found
  66      * @throws PfModelException on errors getting service templates
  67      */
  68     public List<ToscaServiceTemplate> getServiceTemplateList(PfDao dao, String name, String version)
  69             throws PfModelException {
  70
  71         synchronized (providerLockObject) {
  72             LOGGER.debug("->getServiceTemplateList: name={}, version={}", name, version);
  73
  74             List<ToscaServiceTemplate> serviceTemplateList = new ArrayList<>();
  75
  76             try {
  77                 ToscaServiceTemplate serviceTemplate =
  78                         new SimpleToscaProvider().getServiceTemplate(dao).toAuthorative();
  79                 serviceTemplateList.add(serviceTemplate);
  80             } catch (PfModelRuntimeException pfme) {
  81                 return handlePfModelRuntimeException(pfme);
  82             }
  83
  84             LOGGER.debug("<-getServiceTemplateList: name={}, version={}, serviceTemplateList={}", name, version,
  85                     serviceTemplateList);
  86             return serviceTemplateList;
  87         }
  88     }
  89
  90     /**
  91      * Get filtered service templates.
  92      *
  93      * @param pfDao the DAO to use to access the database
  94      * @param filter the filter for the service templates to get
  95      * @return the service templates found
  96      * @throws PfModelException on errors getting service templates
  97      */
  98     public List<ToscaServiceTemplate> getFilteredServiceTemplateList(PfDao pfDao,
  99             @NonNull ToscaEntityFilter<ToscaServiceTemplate> filter) throws PfModelException {
 100
 101         LOGGER.debug("->getFilteredServiceTemplateList: filter={}", filter);
 102
 103         List<ToscaServiceTemplate> filteredServiceTemplateList =
 104                 filter.filter(getServiceTemplateList(pfDao, null, null));
 105
 106         LOGGER.debug("<-getFilteredServiceTemplateList: filter={}, filteredServiceTemplateList={}", filter,
 107                 filteredServiceTemplateList);
 108
 109         return filteredServiceTemplateList;
 110     }
 111
 112     /**
 113      * Create a service template.
 114      *
 115      * @param dao the DAO to use to access the database
 116      * @param serviceTemplate the service template to be created.
 117      * @return the TOSCA service template that was created
 118      * @throws PfModelException on errors creating the service template
 119      */
 120     public ToscaServiceTemplate createServiceTemplate(@NonNull final PfDao dao,
 121             @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
 122
 123         synchronized (providerLockObject) {
 124             LOGGER.debug("->createServiceTemplate: serviceTemplate={}", serviceTemplate);
 125
 126             ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
 127                     .appendToServiceTemplate(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
 128
 129             LOGGER.debug("<-createServiceTemplate: createdServiceTemplate={}", createdServiceTemplate);
 130             return createdServiceTemplate;
 131         }
 132     }
 133
 134     /**
 135      * Update a service template.
 136      *
 137      * @param dao the DAO to use to access the database
 138      * @param serviceTemplate the service template to be updated.
 139      * @return the TOSCA service template that was updated
 140      * @throws PfModelException on errors updating the service template
 141      */
 142     public ToscaServiceTemplate updateServiceTemplate(@NonNull final PfDao dao,
 143             @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
 144
 145         synchronized (providerLockObject) {
 146             LOGGER.debug("->updateServiceTemplate: serviceTemplate={}", serviceTemplate);
 147
 148             ToscaServiceTemplate updatedServiceTemplate = new SimpleToscaProvider()
 149                     .appendToServiceTemplate(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
 150
 151             LOGGER.debug("<-updateServiceTemplate: updatedServiceTemplate={}", updatedServiceTemplate);
 152             return updatedServiceTemplate;
 153         }
 154     }
 155
 156     /**
 157      * Delete a service template.
 158      *
 159      * @param dao the DAO to use to access the database
 160      * @param name the name of the service template to delete.
 161      * @param version the version of the service template to delete.
 162      * @return the TOSCA service template that was deleted
 163      * @throws PfModelException on errors deleting the control loop
 164      */
 165     public ToscaServiceTemplate deleteServiceTemplate(@NonNull final PfDao dao, @NonNull final String name,
 166             @NonNull final String version) throws PfModelException {
 167
 168         synchronized (providerLockObject) {
 169             LOGGER.debug("->deleteServiceTemplate: name={}, version={}", name, version);
 170
 171             ToscaServiceTemplate deletedServiceTemplate =
 172                     new SimpleToscaProvider().deleteServiceTemplate(dao).toAuthorative();
 173
 174             LOGGER.debug("<-deleteServiceTemplate: name={}, version={}, deletedServiceTemplate={}", name, version,
 175                     deletedServiceTemplate);
 176             return deletedServiceTemplate;
 177         }
 178     }
 179
 180     /**
 181      * Get policy types.
 182      *
 183      * @param dao the DAO to use to access the database
 184      * @param name the name of the policy type to get.
 185      * @param version the version of the policy type to get.
 186      * @return the policy types found
 187      * @throws PfModelException on errors getting policy types
 188      */
 189     public ToscaServiceTemplate getPolicyTypes(@NonNull final PfDao dao, final String name, final String version)
 190             throws PfModelException {
 191
 192         synchronized (providerLockObject) {
 193             LOGGER.debug("->getPolicyTypes: name={}, version={}", name, version);
 194
 195             JpaToscaServiceTemplate jpaServiceTemplate = new SimpleToscaProvider().getPolicyTypes(dao, name, version);
 196
 197             ToscaServiceTemplate serviceTemplate = jpaServiceTemplate.toAuthorative();
 198
 199             LOGGER.debug("<-getPolicyTypes: name={}, version={}, serviceTemplate={}", name, version, serviceTemplate);
 200             return serviceTemplate;
 201         }
 202     }
 203
 204     /**
 205      * Get policy types.
 206      *
 207      * @param dao the DAO to use to access the database
 208      * @param name the name of the policy type to get, set to null to get all policy types
 209      * @param version the version of the policy type to get, set to null to get all versions
 210      * @return the policy types found
 211      * @throws PfModelException on errors getting policy types
 212      */
 213     public List<ToscaPolicyType> getPolicyTypeList(@NonNull final PfDao dao, final String name, final String version)
 214             throws PfModelException {
 215
 216         synchronized (providerLockObject) {
 217             LOGGER.debug("->getPolicyTypeList: name={}, version={}", name, version);
 218
 219             List<ToscaPolicyType> policyTypeList;
 220
 221             try {
 222                 policyTypeList = new ArrayList<>(new SimpleToscaProvider().getPolicyTypes(dao, name, version)
 223                         .toAuthorative().getPolicyTypes().values());
 224             } catch (PfModelRuntimeException pfme) {
 225                 return handlePfModelRuntimeException(pfme);
 226             }
 227
 228             LOGGER.debug("<-getPolicyTypeList: name={}, version={}, policyTypeList={}", name, version, policyTypeList);
 229             return policyTypeList;
 230         }
 231     }
 232
 233     /**
 234      * Get filtered policy types.
 235      *
 236      * @param dao the DAO to use to access the database
 237      * @param filter the filter for the policy types to get
 238      * @return the policy types found
 239      * @throws PfModelException on errors getting policy types
 240      */
 241     public ToscaServiceTemplate getFilteredPolicyTypes(@NonNull final PfDao dao,
 242             @NonNull final ToscaEntityFilter<ToscaPolicyType> filter) throws PfModelException {
 243
 244         synchronized (providerLockObject) {
 245             LOGGER.debug("->getFilteredPolicyTypes: filter={}", filter);
 246             SimpleToscaProvider simpleToscaProvider = new SimpleToscaProvider();
 247
 248             final JpaToscaServiceTemplate dbServiceTemplate = simpleToscaProvider.getPolicyTypes(dao, null, null);
 249
 250             List<ToscaPolicyType> filteredPolicyTypes = dbServiceTemplate.getPolicyTypes().toAuthorativeList();
 251             filteredPolicyTypes = filter.filter(filteredPolicyTypes);
 252
 253             if (CollectionUtils.isEmpty(filteredPolicyTypes)) {
 254                 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
 255                         "policy types for filter " + filter.toString() + " do not exist");
 256             }
 257
 258             JpaToscaServiceTemplate filteredServiceTemplate = new JpaToscaServiceTemplate();
 259
 260             for (ToscaPolicyType policyType : filteredPolicyTypes) {
 261                 JpaToscaServiceTemplate cascadedServiceTemplate = simpleToscaProvider
 262                         .getCascadedPolicyTypes(dbServiceTemplate, policyType.getName(), policyType.getVersion());
 263
 264                 filteredServiceTemplate =
 265                         ToscaServiceTemplateUtils.addFragment(filteredServiceTemplate, cascadedServiceTemplate);
 266             }
 267
 268             ToscaServiceTemplate returnServiceTemplate = filteredServiceTemplate.toAuthorative();
 269
 270             LOGGER.debug("<-getFilteredPolicyTypes: filter={}, serviceTemplate={}", filter, returnServiceTemplate);
 271             return returnServiceTemplate;
 272         }
 273     }
 274
 275     /**
 276      * Get filtered policy types.
 277      *
 278      * @param dao the DAO to use to access the database
 279      * @param filter the filter for the policy types to get
 280      * @return the policy types found
 281      * @throws PfModelException on errors getting policy types
 282      */
 283     public List<ToscaPolicyType> getFilteredPolicyTypeList(@NonNull final PfDao dao,
 284             @NonNull final ToscaEntityFilter<ToscaPolicyType> filter) throws PfModelException {
 285
 286         LOGGER.debug("->getFilteredPolicyTypeList: filter={}", filter);
 287
 288         List<ToscaPolicyType> filteredPolicyTypeList = filter.filter(getPolicyTypeList(dao, null, null));
 289
 290         LOGGER.debug("<-getFilteredPolicyTypeList: filter={}, filteredPolicyTypeList={}", filter,
 291                 filteredPolicyTypeList);
 292
 293         return filteredPolicyTypeList;
 294     }
 295
 296     /**
 297      * Create policy types.
 298      *
 299      * @param dao the DAO to use to access the database
 300      * @param serviceTemplate the service template containing the definition of the policy types to be created
 301      * @return the TOSCA service template containing the created policy types
 302      * @throws PfModelException on errors creating policy types
 303      */
 304     public ToscaServiceTemplate createPolicyTypes(@NonNull final PfDao dao,
 305             @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
 306
 307         synchronized (providerLockObject) {
 308             LOGGER.debug("->createPolicyTypes: serviceTemplate={}", serviceTemplate);
 309
 310             ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
 311                     .createPolicyTypes(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
 312
 313             LOGGER.debug("<-createPolicyTypes: createdServiceTemplate={}", createdServiceTemplate);
 314             return createdServiceTemplate;
 315         }
 316     }
 317
 318     /**
 319      * Update policy types.
 320      *
 321      * @param dao the DAO to use to access the database
 322      * @param serviceTemplate the service template containing the definition of the policy types to be modified
 323      * @return the TOSCA service template containing the modified policy types
 324      * @throws PfModelException on errors updating policy types
 325      */
 326     public ToscaServiceTemplate updatePolicyTypes(@NonNull final PfDao dao,
 327             @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
 328
 329         synchronized (providerLockObject) {
 330             LOGGER.debug("->updatePolicyTypes: serviceTemplate={}", serviceTemplate);
 331
 332             ToscaServiceTemplate updatedServiceTemplate = new SimpleToscaProvider()
 333                     .updatePolicyTypes(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
 334
 335             LOGGER.debug("<-updatePolicyTypes: updatedServiceTemplate={}", updatedServiceTemplate);
 336             return updatedServiceTemplate;
 337         }
 338     }
 339
 340     /**
 341      * Delete policy type.
 342      *
 343      * @param dao the DAO to use to access the database
 344      * @param name the name of the policy type to delete.
 345      * @param version the version of the policy type to delete.
 346      * @return the TOSCA service template containing the policy type that was deleted
 347      * @throws PfModelException on errors deleting policy types
 348      */
 349     public ToscaServiceTemplate deletePolicyType(@NonNull final PfDao dao, @NonNull final String name,
 350             @NonNull final String version) throws PfModelException {
 351
 352         synchronized (providerLockObject) {
 353             LOGGER.debug("->deletePolicyType: name={}, version={}", name, version);
 354
 355             ToscaServiceTemplate deletedServiceTemplate =
 356                     new SimpleToscaProvider().deletePolicyType(dao, new PfConceptKey(name, version)).toAuthorative();
 357
 358             LOGGER.debug("<-deletePolicyType: name={}, version={}, deletedServiceTemplate={}", name, version,
 359                     deletedServiceTemplate);
 360             return deletedServiceTemplate;
 361         }
 362     }
 363
 364     /**
 365      * Get policies.
 366      *
 367      * @param dao the DAO to use to access the database
 368      * @param name the name of the policy to get.
 369      * @param version the version of the policy to get.
 370      * @return the policies found
 371      * @throws PfModelException on errors getting policies
 372      */
 373     public ToscaServiceTemplate getPolicies(@NonNull final PfDao dao, final String name, final String version)
 374             throws PfModelException {
 375
 376         synchronized (providerLockObject) {
 377             LOGGER.debug("->getPolicies: name={}, version={}", name, version);
 378
 379             ToscaServiceTemplate gotServiceTemplate =
 380                     new SimpleToscaProvider().getPolicies(dao, name, version).toAuthorative();
 381
 382             LOGGER.debug("<-getPolicies: name={}, version={}, gotServiceTemplate={}", name, version,
 383                     gotServiceTemplate);
 384             return gotServiceTemplate;
 385         }
 386     }
 387
 388     /**
 389      * Get policies.
 390      *
 391      * @param dao the DAO to use to access the database
 392      * @param name the name of the policy to get, null to get all policies
 393      * @param version the version of the policy to get, null to get all versions of a policy
 394      * @return the policies found
 395      * @throws PfModelException on errors getting policies
 396      */
 397     public List<ToscaPolicy> getPolicyList(@NonNull final PfDao dao, final String name, final String version)
 398             throws PfModelException {
 399
 400         synchronized (providerLockObject) {
 401             LOGGER.debug("->getPolicyList: name={}, version={}", name, version);
 402
 403             List<ToscaPolicy> policyList;
 404
 405             try {
 406                 policyList = asConceptList(new SimpleToscaProvider().getPolicies(dao, name, version).toAuthorative()
 407                         .getToscaTopologyTemplate().getPolicies());
 408             } catch (PfModelRuntimeException pfme) {
 409                 return handlePfModelRuntimeException(pfme);
 410             }
 411
 412             LOGGER.debug("<-getPolicyList: name={}, version={}, policyList={}", name, version, policyList);
 413             return policyList;
 414         }
 415     }
 416
 417     /**
 418      * Get filtered policies.
 419      *
 420      * @param dao the DAO to use to access the database
 421      * @param filter the filter for the policies to get
 422      * @return the policies found
 423      * @throws PfModelException on errors getting policies
 424      */
 425     public ToscaServiceTemplate getFilteredPolicies(@NonNull final PfDao dao,
 426             @NonNull final ToscaTypedEntityFilter<ToscaPolicy> filter) throws PfModelException {
 427
 428         synchronized (providerLockObject) {
 429             LOGGER.debug("->getFilteredPolicies: filter={}", filter);
 430             String version =
 431                     ToscaTypedEntityFilter.LATEST_VERSION.equals(filter.getVersion()) ? null : filter.getVersion();
 432
 433             SimpleToscaProvider simpleToscaProvider = new SimpleToscaProvider();
 434             final JpaToscaServiceTemplate dbServiceTemplate =
 435                     simpleToscaProvider.getPolicies(dao, filter.getName(), version);
 436
 437             List<ToscaPolicy> filteredPolicies =
 438                     dbServiceTemplate.getTopologyTemplate().getPolicies().toAuthorativeList();
 439             filteredPolicies = filter.filter(filteredPolicies);
 440
 441             if (CollectionUtils.isEmpty(filteredPolicies)) {
 442                 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
 443                         "policies for filter " + filter.toString() + " do not exist");
 444             }
 445
 446             JpaToscaServiceTemplate filteredServiceTemplate = new JpaToscaServiceTemplate();
 447
 448             for (ToscaPolicy policy : filteredPolicies) {
 449                 JpaToscaServiceTemplate cascadedServiceTemplate = simpleToscaProvider
 450                         .getCascadedPolicies(dbServiceTemplate, policy.getName(), policy.getVersion());
 451
 452                 filteredServiceTemplate =
 453                         ToscaServiceTemplateUtils.addFragment(filteredServiceTemplate, cascadedServiceTemplate);
 454             }
 455
 456             ToscaServiceTemplate returnServiceTemplate = filteredServiceTemplate.toAuthorative();
 457
 458             LOGGER.debug("<-getFilteredPolicies: filter={}, serviceTemplate={}", filter, returnServiceTemplate);
 459             return returnServiceTemplate;
 460         }
 461     }
 462
 463     /**
 464      * Get filtered policies.
 465      *
 466      * @param dao the DAO to use to access the database
 467      * @param filter the filter for the policies to get
 468      * @return the policies found
 469      * @throws PfModelException on errors getting policies
 470      */
 471     public List<ToscaPolicy> getFilteredPolicyList(@NonNull final PfDao dao,
 472             @NonNull final ToscaTypedEntityFilter<ToscaPolicy> filter) throws PfModelException {
 473
 474         LOGGER.debug("->getFilteredPolicyList: filter={}", filter);
 475         String version = ToscaTypedEntityFilter.LATEST_VERSION.equals(filter.getVersion()) ? null : filter.getVersion();
 476
 477         List<ToscaPolicy> policyList = filter.filter(getPolicyList(dao, filter.getName(), version));
 478
 479         LOGGER.debug("<-getFilteredPolicyList: filter={}, policyList={}", filter, policyList);
 480         return policyList;
 481     }
 482
 483     /**
 484      * Create policies.
 485      *
 486      * @param dao the DAO to use to access the database
 487      * @param serviceTemplate the service template containing the definitions of the new policies to be created.
 488      * @return the TOSCA service template containing the policy types that were created
 489      * @throws PfModelException on errors creating policies
 490      */
 491     public ToscaServiceTemplate createPolicies(@NonNull final PfDao dao,
 492             @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
 493
 494         synchronized (providerLockObject) {
 495             LOGGER.debug("->createPolicies: serviceTemplate={}", serviceTemplate);
 496
 497             ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
 498                     .createPolicies(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
 499
 500             LOGGER.debug("<-createPolicies: createdServiceTemplate={}", createdServiceTemplate);
 501             return createdServiceTemplate;
 502         }
 503     }
 504
 505     /**
 506      * Update policies.
 507      *
 508      * @param dao the DAO to use to access the database
 509      * @param serviceTemplate the service template containing the definitions of the policies to be updated.
 510      * @return the TOSCA service template containing the policies that were updated
 511      * @throws PfModelException on errors updating policies
 512      */
 513     public ToscaServiceTemplate updatePolicies(@NonNull final PfDao dao,
 514             @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
 515
 516         synchronized (providerLockObject) {
 517             LOGGER.debug("->updatePolicies: serviceTemplate={}", serviceTemplate);
 518
 519             ToscaServiceTemplate updatedServiceTemplate = new SimpleToscaProvider()
 520                     .updatePolicies(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
 521
 522             LOGGER.debug("<-updatePolicies: updatedServiceTemplate={}", updatedServiceTemplate);
 523             return updatedServiceTemplate;
 524         }
 525     }
 526
 527     /**
 528      * Delete policy.
 529      *
 530      * @param dao the DAO to use to access the database
 531      * @param name the name of the policy to delete.
 532      * @param version the version of the policy to delete.
 533      * @return the TOSCA service template containing the policy that was deleted
 534      * @throws PfModelException on errors deleting policies
 535      */
 536     public ToscaServiceTemplate deletePolicy(@NonNull final PfDao dao, @NonNull final String name,
 537             @NonNull final String version) throws PfModelException {
 538
 539         synchronized (providerLockObject) {
 540             LOGGER.debug("->deletePolicy: name={}, version={}", name, version);
 541
 542             ToscaServiceTemplate deletedServiceTemplate =
 543                     new SimpleToscaProvider().deletePolicy(dao, new PfConceptKey(name, version)).toAuthorative();
 544
 545             LOGGER.debug("<-deletePolicy: name={}, version={}, deletedServiceTemplate={}", name, version,
 546                     deletedServiceTemplate);
 547             return deletedServiceTemplate;
 548         }
 549     }
 550
 551     /**
 552      * Return the contents of a list of maps as a plain list.
 553      *
 554      * @param listOfMaps the list of maps
 555      * @return the plain list
 556      */
 557     private <T> List<T> asConceptList(final List<Map<String, T>> listOfMaps) {
 558         List<T> returnList = new ArrayList<>();
 559         for (Map<String, T> conceptMap : listOfMaps) {
 560             for (T concept : conceptMap.values()) {
 561                 returnList.add(concept);
 562             }
 563         }
 564
 565         return returnList;
 566     }
 567
 568     /**
 569      * Handle a PfModelRuntimeException on a list call.
 570      *
 571      * @param pfme the model exception
 572      * @return an empty list on 404
 573      */
 574     private <T extends ToscaEntity> List<T> handlePfModelRuntimeException(final PfModelRuntimeException pfme) {
 575         if (Status.NOT_FOUND.equals(pfme.getErrorResponse().getResponseCode())) {
 576             LOGGER.trace("request did not find any results", pfme);
 577             return Collections.emptyList();
 578         } else {
 579             throw pfme;
 580         }
 581     }
 582 }