main/src/main/java/org/onap/policy/api/main/rest/ApiRestController.java

   1 /*-\r
   2  * ============LICENSE_START=======================================================\r
   3  * ONAP Policy API\r
   4  * ================================================================================\r
   5  * Copyright (C) 2018 Samsung Electronics Co., Ltd. All rights reserved.\r
   6  * Modifications Copyright (C) 2019-2021 AT&T Intellectual Property. All rights reserved.\r
   7  * Modifications Copyright (C) 2020-2022 Nordix Foundation.\r
   8  * Modifications Copyright (C) 2020-2023 Bell Canada. All rights reserved.\r
   9  * ================================================================================\r
  10  * Licensed under the Apache License, Version 2.0 (the "License");\r
  11  * you may not use this file except in compliance with the License.\r
  12  * You may obtain a copy of the License at\r
  13  *\r
  14  *      http://www.apache.org/licenses/LICENSE-2.0\r
  15  *\r
  16  * Unless required by applicable law or agreed to in writing, software\r
  17  * distributed under the License is distributed on an "AS IS" BASIS,\r
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  19  * See the License for the specific language governing permissions and\r
  20  * limitations under the License.\r
  21  *\r
  22  * SPDX-License-Identifier: Apache-2.0\r
  23  * ============LICENSE_END=========================================================\r
  24  */\r
  25 \r
  26 package org.onap.policy.api.main.rest;\r
  27 \r
  28 import java.util.List;\r
  29 import java.util.UUID;\r
  30 import javax.ws.rs.core.Response.Status;\r
  31 import lombok.RequiredArgsConstructor;\r
  32 import org.onap.policy.api.main.exception.PolicyApiRuntimeException;\r
  33 import org.onap.policy.api.main.rest.genapi.PolicyDesignApi;\r
  34 import org.onap.policy.api.main.rest.provider.healthcheck.HealthCheckProvider;\r
  35 import org.onap.policy.api.main.service.ToscaServiceTemplateService;\r
  36 import org.onap.policy.common.endpoints.event.comm.Topic.CommInfrastructure;\r
  37 import org.onap.policy.common.endpoints.report.HealthCheckReport;\r
  38 import org.onap.policy.common.endpoints.utils.NetLoggerUtil;\r
  39 import org.onap.policy.common.endpoints.utils.NetLoggerUtil.EventType;\r
  40 import org.onap.policy.models.base.PfModelException;\r
  41 import org.onap.policy.models.base.PfModelRuntimeException;\r
  42 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;\r
  43 import org.springframework.context.annotation.Profile;\r
  44 import org.springframework.http.HttpMethod;\r
  45 import org.springframework.http.HttpStatus;\r
  46 import org.springframework.http.ResponseEntity;\r
  47 import org.springframework.web.bind.annotation.RestController;\r
  48 \r
  49 /**\r
  50  * Class to provide REST API services.\r
  51  *\r
  52  * @author Chenfei Gao (cgao@research.att.com)\r
  53  */\r
  54 @RestController\r
  55 @RequiredArgsConstructor\r
  56 @Profile("default")\r
  57 public class ApiRestController extends CommonRestController implements PolicyDesignApi {\r
  58 \r
  59     private enum Target {\r
  60         POLICY,\r
  61         POLICY_TYPE,\r
  62         OTHER\r
  63     }\r
  64 \r
  65     private final ToscaServiceTemplateService toscaServiceTemplateService;\r
  66     private final HealthCheckProvider healthCheckProvider;\r
  67 \r
  68     /**\r
  69      * Retrieves the healthcheck status of the API component.\r
  70      *\r
  71      * @return the Response object containing the results of the API operation\r
  72      */\r
  73     @Override\r
  74     public ResponseEntity<HealthCheckReport> getHealthCheck(UUID requestId) {\r
  75         final var report = healthCheckProvider.performHealthCheck();\r
  76         return makeResponse(requestId, report, report.getCode());\r
  77     }\r
  78 \r
  79     /**\r
  80      * Retrieves all available policy types.\r
  81      *\r
  82      * @return the Response object containing the results of the API operation\r
  83      */\r
  84     @Override\r
  85     public ResponseEntity<ToscaServiceTemplate> getAllPolicyTypes(UUID requestId) {\r
  86         try {\r
  87             ToscaServiceTemplate serviceTemplate = toscaServiceTemplateService.fetchPolicyTypes(null, null);\r
  88             return makeOkResponse(requestId, serviceTemplate);\r
  89         } catch (PfModelException | PfModelRuntimeException pfme) {\r
  90             final var msg = "GET /policytypes";\r
  91             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
  92         }\r
  93     }\r
  94 \r
  95     /**\r
  96      * Retrieves all versions of a particular policy type.\r
  97      *\r
  98      * @param policyTypeId the ID of specified policy type\r
  99      *\r
 100      * @return the Response object containing the results of the API operation\r
 101      */\r
 102     @Override\r
 103     public ResponseEntity<ToscaServiceTemplate> getAllVersionsOfPolicyType(\r
 104             String policyTypeId,\r
 105             UUID requestId) {\r
 106         try {\r
 107             ToscaServiceTemplate serviceTemplate = toscaServiceTemplateService.fetchPolicyTypes(policyTypeId, null);\r
 108             return makeOkResponse(requestId, serviceTemplate);\r
 109         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 110             var msg = String.format("GET /policytypes/%s", policyTypeId);\r
 111             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 112         }\r
 113     }\r
 114 \r
 115     /**\r
 116      * Retrieves specified version of a particular policy type.\r
 117      *\r
 118      * @param policyTypeId the ID of specified policy type\r
 119      * @param versionId the version of specified policy type\r
 120      *\r
 121      * @return the Response object containing the results of the API operation\r
 122      */\r
 123     @Override\r
 124     public ResponseEntity<ToscaServiceTemplate> getSpecificVersionOfPolicyType(\r
 125             String policyTypeId,\r
 126             String versionId,\r
 127             UUID requestId) {\r
 128         try {\r
 129             ToscaServiceTemplate serviceTemplate =\r
 130                 toscaServiceTemplateService.fetchPolicyTypes(policyTypeId, versionId);\r
 131             return makeOkResponse(requestId, serviceTemplate);\r
 132         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 133             var msg = String.format("GET /policytypes/%s/versions/%s", policyTypeId, versionId);\r
 134             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 135         }\r
 136     }\r
 137 \r
 138     /**\r
 139      * Retrieves latest version of a particular policy type.\r
 140      *\r
 141      * @param policyTypeId the ID of specified policy type\r
 142      *\r
 143      * @return the Response object containing the results of the API operation\r
 144      */\r
 145     @Override\r
 146     public ResponseEntity<ToscaServiceTemplate> getLatestVersionOfPolicyType(\r
 147             String policyTypeId,\r
 148             UUID requestId) {\r
 149         try {\r
 150             ToscaServiceTemplate serviceTemplate = toscaServiceTemplateService.fetchLatestPolicyTypes(policyTypeId);\r
 151             return makeOkResponse(requestId, serviceTemplate);\r
 152         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 153             var msg = String.format("GET /policytypes/%s/versions/latest", policyTypeId);\r
 154             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 155         }\r
 156     }\r
 157 \r
 158     /**\r
 159      * Creates a new policy type.\r
 160      *\r
 161      * @param body the body of policy type following TOSCA definition\r
 162      *\r
 163      * @return the Response object containing the results of the API operation\r
 164      */\r
 165     @Override\r
 166     public ResponseEntity<ToscaServiceTemplate> createPolicyType(\r
 167             ToscaServiceTemplate body,\r
 168             UUID requestId) {\r
 169         if (NetLoggerUtil.getNetworkLogger().isInfoEnabled()) {\r
 170             NetLoggerUtil.log(EventType.IN, CommInfrastructure.REST, "/policytypes", toJson(body));\r
 171         }\r
 172         try {\r
 173             ToscaServiceTemplate serviceTemplate = toscaServiceTemplateService.createPolicyType(body);\r
 174             return makeOkResponse(requestId, serviceTemplate);\r
 175         } catch (PfModelRuntimeException pfme) {\r
 176             final var msg = "POST /policytypes";\r
 177             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 178         }\r
 179     }\r
 180 \r
 181     /**\r
 182      * Deletes specified version of a particular policy type.\r
 183      *\r
 184      * @param policyTypeId the ID of specified policy type\r
 185      * @param versionId the version of specified policy type\r
 186      *\r
 187      * @return the Response object containing the results of the API operation\r
 188      */\r
 189     @Override\r
 190     public ResponseEntity<ToscaServiceTemplate> deleteSpecificVersionOfPolicyType(\r
 191             String policyTypeId,\r
 192             String versionId,\r
 193             UUID requestId) {\r
 194         try {\r
 195             ToscaServiceTemplate serviceTemplate =\r
 196                 toscaServiceTemplateService.deletePolicyType(policyTypeId, versionId);\r
 197             return makeOkResponse(requestId, serviceTemplate);\r
 198         } catch (PfModelRuntimeException pfme) {\r
 199             var msg = String.format("DELETE /policytypes/%s/versions/%s", policyTypeId, versionId);\r
 200             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 201         }\r
 202     }\r
 203 \r
 204     /**\r
 205      * Retrieves all versions of a particular policy.\r
 206      *\r
 207      * @param policyTypeId the ID of specified policy type\r
 208      * @param policyTypeVersion the version of specified policy type\r
 209      *\r
 210      * @return the Response object containing the results of the API operation\r
 211      */\r
 212     @Override\r
 213     public ResponseEntity<ToscaServiceTemplate> getAllPolicies(\r
 214             String policyTypeId,\r
 215             String policyTypeVersion,\r
 216             PolicyFetchMode mode,\r
 217             UUID requestId) {\r
 218         try {\r
 219             ToscaServiceTemplate serviceTemplate =\r
 220                 toscaServiceTemplateService.fetchPolicies(policyTypeId, policyTypeVersion, null, null, mode);\r
 221             return makeOkResponse(requestId, serviceTemplate);\r
 222         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 223             var msg = String.format("GET /policytypes/%s/versions/%s/policies", policyTypeId, policyTypeVersion);\r
 224             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 225         }\r
 226     }\r
 227 \r
 228     /**\r
 229      * Retrieves all versions of a particular policy.\r
 230      *\r
 231      * @param policyTypeId the ID of specified policy type\r
 232      * @param policyTypeVersion the version of specified policy type\r
 233      * @param policyId the ID of specified policy\r
 234      *\r
 235      * @return the Response object containing the results of the API operation\r
 236      */\r
 237     @Override\r
 238     public ResponseEntity<ToscaServiceTemplate> getAllVersionsOfPolicy(\r
 239             String policyId,\r
 240             String policyTypeId,\r
 241             String policyTypeVersion,\r
 242             PolicyFetchMode mode,\r
 243             UUID requestId) {\r
 244         try {\r
 245             ToscaServiceTemplate serviceTemplate =\r
 246                 toscaServiceTemplateService.fetchPolicies(policyTypeId, policyTypeVersion, policyId, null, mode);\r
 247             return makeOkResponse(requestId, serviceTemplate);\r
 248         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 249             var msg = String.format("/policytypes/%s/versions/%s/policies/%s",\r
 250                 policyTypeId, policyTypeVersion, policyId);\r
 251             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 252         }\r
 253     }\r
 254 \r
 255     /**\r
 256      * Retrieves the specified version of a particular policy.\r
 257      *\r
 258      * @param policyTypeId the ID of specified policy type\r
 259      * @param policyTypeVersion the version of specified policy type\r
 260      * @param policyId the ID of specified policy\r
 261      * @param policyVersion the version of specified policy\r
 262      *\r
 263      * @return the Response object containing the results of the API operation\r
 264      */\r
 265     @Override\r
 266     public ResponseEntity<ToscaServiceTemplate> getSpecificVersionOfPolicy(\r
 267             String policyId,\r
 268             String policyTypeId,\r
 269             String policyTypeVersion,\r
 270             String policyVersion,\r
 271             PolicyFetchMode mode,\r
 272             UUID requestId) {\r
 273         try {\r
 274             ToscaServiceTemplate serviceTemplate = toscaServiceTemplateService\r
 275                 .fetchPolicies(policyTypeId, policyTypeVersion, policyId, policyVersion, mode);\r
 276             return makeOkResponse(requestId, serviceTemplate);\r
 277         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 278             var msg = String.format("GET /policytypes/%s/versions/%s/policies/%s/versions/%s",\r
 279                 policyTypeId, policyTypeVersion, policyId, policyVersion);\r
 280             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 281         }\r
 282     }\r
 283 \r
 284     /**\r
 285      * Retrieves the latest version of a particular policy.\r
 286      *\r
 287      * @param policyTypeId the ID of specified policy type\r
 288      * @param policyTypeVersion the version of specified policy type\r
 289      * @param policyId the ID of specified policy\r
 290      *\r
 291      * @return the Response object containing the results of the API operation\r
 292      */\r
 293     @Override\r
 294     public ResponseEntity<ToscaServiceTemplate> getLatestVersionOfPolicy(\r
 295             String policyId,\r
 296             String policyTypeId,\r
 297             String policyTypeVersion,\r
 298             PolicyFetchMode mode,\r
 299             UUID requestId) {\r
 300         try {\r
 301             ToscaServiceTemplate serviceTemplate =\r
 302                 toscaServiceTemplateService.fetchLatestPolicies(policyTypeId, policyTypeVersion, policyId, mode);\r
 303             return makeOkResponse(requestId, serviceTemplate);\r
 304         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 305             var msg = String.format("GET /policytypes/%s/versions/%s/policies/%s/versions/latest",\r
 306                 policyTypeId, policyTypeVersion, policyId);\r
 307             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 308         }\r
 309     }\r
 310 \r
 311     /**\r
 312      * Creates a new policy for a particular policy type and version.\r
 313      *\r
 314      * @param policyTypeId the ID of specified policy type\r
 315      * @param policyTypeVersion the version of specified policy type\r
 316      * @param body the body of policy following TOSCA definition\r
 317      *\r
 318      * @return the Response object containing the results of the API operation\r
 319      */\r
 320     @Override\r
 321     public ResponseEntity<ToscaServiceTemplate> createPolicy(\r
 322             String policyTypeId,\r
 323             String policyTypeVersion,\r
 324             ToscaServiceTemplate body,\r
 325             UUID requestId) {\r
 326         if (NetLoggerUtil.getNetworkLogger().isInfoEnabled()) {\r
 327             NetLoggerUtil.log(EventType.IN, CommInfrastructure.REST,\r
 328                 "/policytypes/" + policyTypeId + "/versions/" + policyTypeVersion + "/policies", toJson(body));\r
 329         }\r
 330         try {\r
 331             ToscaServiceTemplate serviceTemplate =\r
 332                 toscaServiceTemplateService.createPolicy(policyTypeId, policyTypeVersion, body);\r
 333             return makeOkResponse(requestId, serviceTemplate);\r
 334         } catch (PfModelRuntimeException pfme) {\r
 335             var msg = String.format("POST /policytypes/%s/versions/%s/policies", policyTypeId, policyTypeVersion);\r
 336             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 337         }\r
 338     }\r
 339 \r
 340     /**\r
 341      * Deletes the specified version of a particular policy.\r
 342      *\r
 343      * @param policyTypeId the ID of specified policy type\r
 344      * @param policyTypeVersion the version of specified policy type\r
 345      * @param policyId the ID of specified policy\r
 346      * @param policyVersion the version of specified policy\r
 347      *\r
 348      * @return the Response object containing the results of the API operation\r
 349      */\r
 350     @Override\r
 351     public ResponseEntity<ToscaServiceTemplate> deleteSpecificVersionOfPolicy(\r
 352         String policyTypeId,\r
 353         String policyTypeVersion,\r
 354         String policyId,\r
 355         String policyVersion,\r
 356         UUID requestId) {\r
 357         try {\r
 358             ToscaServiceTemplate serviceTemplate =\r
 359                 toscaServiceTemplateService.deletePolicy(policyTypeId, policyTypeVersion, policyId, policyVersion);\r
 360             return makeOkResponse(requestId, serviceTemplate);\r
 361         } catch (PfModelRuntimeException pfme) {\r
 362             var msg = String.format("DELETE /policytypes/%s/versions/%s/policies/%s/versions/%s",\r
 363                 policyTypeId, policyTypeVersion, policyId, policyVersion);\r
 364             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 365         }\r
 366     }\r
 367 \r
 368     /**\r
 369      * Retrieves all the available policies.\r
 370      *\r
 371      * @return the Response object containing the results of the API operation\r
 372      */\r
 373     @Override\r
 374     public ResponseEntity<ToscaServiceTemplate> getPolicies(\r
 375             PolicyFetchMode mode,\r
 376             UUID requestId) {\r
 377         try {\r
 378             ToscaServiceTemplate serviceTemplate =\r
 379                 toscaServiceTemplateService.fetchPolicies(null, null, null, null, mode);\r
 380             return makeOkResponse(requestId, serviceTemplate);\r
 381         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 382             final var msg = "GET /policies/ --";\r
 383             if (pfme.getErrorResponse().getResponseCode().equals(Status.NOT_FOUND)) {\r
 384                 pfme.getErrorResponse().setErrorMessage(ERROR_MESSAGE_NO_POLICIES_FOUND);\r
 385                 pfme.getErrorResponse().setErrorDetails(List.of(ERROR_MESSAGE_NO_POLICIES_FOUND));\r
 386             }\r
 387             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 388         }\r
 389     }\r
 390 \r
 391     /**\r
 392      * Retrieves the specified version of a particular policy.\r
 393      *\r
 394      * @param policyId the Name of specified policy\r
 395      * @param policyVersion the version of specified policy\r
 396      *\r
 397      * @return the Response object containing the results of the API operation\r
 398      */\r
 399     @Override\r
 400     public ResponseEntity<ToscaServiceTemplate> getSpecificPolicy(\r
 401             String policyId,\r
 402             String policyVersion,\r
 403             PolicyFetchMode mode,\r
 404             UUID requestId) {\r
 405         try {\r
 406             ToscaServiceTemplate serviceTemplate =\r
 407                 toscaServiceTemplateService.fetchPolicies(null, null, policyId, policyVersion, mode);\r
 408             return makeOkResponse(requestId, serviceTemplate);\r
 409         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 410             var msg = String.format("GET /policies/%s/versions/%s", policyId, policyVersion);\r
 411             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 412         }\r
 413     }\r
 414 \r
 415     /**\r
 416      * Creates one or more new policies in one call.\r
 417      *\r
 418      * @param body the body of policy following TOSCA definition\r
 419      *\r
 420      * @return the Response object containing the results of the API operation\r
 421      */\r
 422     @Override\r
 423     public ResponseEntity<ToscaServiceTemplate> createPolicies(\r
 424         ToscaServiceTemplate body,\r
 425         UUID requestId) {\r
 426         if (NetLoggerUtil.getNetworkLogger().isInfoEnabled()) {\r
 427             NetLoggerUtil.log(EventType.IN, CommInfrastructure.REST, "/policies", toJson(body));\r
 428         }\r
 429         try {\r
 430             ToscaServiceTemplate serviceTemplate = toscaServiceTemplateService.createPolicies(body);\r
 431             return makeOkResponse(requestId, serviceTemplate);\r
 432         } catch (PfModelRuntimeException pfme) {\r
 433             final var msg = "POST /policies";\r
 434             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 435         }\r
 436     }\r
 437 \r
 438     /**\r
 439      * Deletes the specified version of a particular policy.\r
 440      *\r
 441      * @param policyId the ID of specified policy\r
 442      * @param policyVersion the version of specified policy\r
 443      *\r
 444      * @return the Response object containing the results of the API operation\r
 445      */\r
 446     @Override\r
 447     public ResponseEntity<ToscaServiceTemplate> deleteSpecificPolicy(\r
 448         String policyId,\r
 449         String policyVersion,\r
 450         UUID requestId) {\r
 451         try {\r
 452             ToscaServiceTemplate serviceTemplate =\r
 453                 toscaServiceTemplateService.deletePolicy(null, null, policyId, policyVersion);\r
 454             return makeOkResponse(requestId, serviceTemplate);\r
 455         } catch (PfModelRuntimeException pfme) {\r
 456             var msg = String.format("DELETE /policies/%s/versions/%s", policyId, policyVersion);\r
 457             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 458         }\r
 459     }\r
 460 }\r