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-2022 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 io.swagger.annotations.Api;\r
  29 import io.swagger.annotations.ApiOperation;\r
  30 import io.swagger.annotations.ApiParam;\r
  31 import io.swagger.annotations.ApiResponse;\r
  32 import io.swagger.annotations.ApiResponses;\r
  33 import io.swagger.annotations.Authorization;\r
  34 import io.swagger.annotations.BasicAuthDefinition;\r
  35 import io.swagger.annotations.Extension;\r
  36 import io.swagger.annotations.ExtensionProperty;\r
  37 import io.swagger.annotations.Info;\r
  38 import io.swagger.annotations.ResponseHeader;\r
  39 import io.swagger.annotations.SecurityDefinition;\r
  40 import io.swagger.annotations.SwaggerDefinition;\r
  41 import java.net.HttpURLConnection;\r
  42 import java.util.List;\r
  43 import java.util.UUID;\r
  44 import javax.ws.rs.core.Response.Status;\r
  45 import org.onap.policy.api.main.exception.PolicyApiRuntimeException;\r
  46 import org.onap.policy.api.main.rest.provider.HealthCheckProvider;\r
  47 import org.onap.policy.api.main.rest.provider.PolicyProvider;\r
  48 import org.onap.policy.api.main.rest.provider.PolicyTypeProvider;\r
  49 import org.onap.policy.api.main.rest.provider.StatisticsProvider;\r
  50 import org.onap.policy.common.endpoints.event.comm.Topic.CommInfrastructure;\r
  51 import org.onap.policy.common.endpoints.report.HealthCheckReport;\r
  52 import org.onap.policy.common.endpoints.utils.NetLoggerUtil;\r
  53 import org.onap.policy.common.endpoints.utils.NetLoggerUtil.EventType;\r
  54 import org.onap.policy.models.base.PfModelException;\r
  55 import org.onap.policy.models.base.PfModelRuntimeException;\r
  56 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;\r
  57 import org.slf4j.Logger;\r
  58 import org.slf4j.LoggerFactory;\r
  59 import org.springframework.beans.factory.annotation.Autowired;\r
  60 import org.springframework.http.HttpMethod;\r
  61 import org.springframework.http.HttpStatus;\r
  62 import org.springframework.http.ResponseEntity;\r
  63 import org.springframework.web.bind.annotation.DeleteMapping;\r
  64 import org.springframework.web.bind.annotation.GetMapping;\r
  65 import org.springframework.web.bind.annotation.PathVariable;\r
  66 import org.springframework.web.bind.annotation.PostMapping;\r
  67 import org.springframework.web.bind.annotation.RequestBody;\r
  68 import org.springframework.web.bind.annotation.RequestHeader;\r
  69 import org.springframework.web.bind.annotation.RequestMapping;\r
  70 import org.springframework.web.bind.annotation.RequestParam;\r
  71 import org.springframework.web.bind.annotation.RestController;\r
  72 \r
  73 /**\r
  74  * Class to provide REST API services.\r
  75  *\r
  76  * @author Chenfei Gao (cgao@research.att.com)\r
  77  */\r
  78 @RestController\r
  79 @RequestMapping(path = "/policy/api/v1", produces = { "application/json", "application/yaml" })\r
  80 @Api(value = "Policy Design API")\r
  81 @SwaggerDefinition(\r
  82     info = @Info(\r
  83         description = "Policy Design API is publicly exposed for clients to Create/Read/Update/Delete"\r
  84             + " policy types, policy type implementation and policies which can be recognized"\r
  85             + " and executable by incorporated policy engines. It is an"\r
  86             + " independent component running rest service that takes all policy design API calls"\r
  87             + " from clients and then assign them to different API working functions. Besides"\r
  88             + " that, API is also exposed for clients to retrieve healthcheck status of this API"\r
  89             + " rest service and the statistics report including the counters of API invocation.",\r
  90         version = "1.0.0", title = "Policy Design",\r
  91         extensions = {@Extension(properties = {@ExtensionProperty(name = "planned-retirement-date", value = "tbd"),\r
  92             @ExtensionProperty(name = "component", value = "Policy Framework")})}),\r
  93     schemes = {SwaggerDefinition.Scheme.HTTP, SwaggerDefinition.Scheme.HTTPS},\r
  94     securityDefinition = @SecurityDefinition(basicAuthDefinitions = {@BasicAuthDefinition(key = "basicAuth")}))\r
  95 public class ApiRestController extends CommonRestController {\r
  96 \r
  97     private enum Target {\r
  98         POLICY,\r
  99         POLICY_TYPE,\r
 100         OTHER\r
 101     }\r
 102 \r
 103     @Autowired\r
 104     private PolicyProvider policyProvider;\r
 105 \r
 106     @Autowired\r
 107     private HealthCheckProvider healthCheckProvider;\r
 108 \r
 109     @Autowired\r
 110     private PolicyTypeProvider policyTypeProvider;\r
 111 \r
 112     @Autowired\r
 113     private ApiStatisticsManager mgr;\r
 114 \r
 115     @Autowired\r
 116     private StatisticsProvider statisticsProvider;\r
 117 \r
 118     /**\r
 119      * Retrieves the healthcheck status of the API component.\r
 120      *\r
 121      * @return the Response object containing the results of the API operation\r
 122      */\r
 123     @GetMapping("/healthcheck")\r
 124     @ApiOperation(value = "Perform a system healthcheck", notes = "Returns healthy status of the Policy API component",\r
 125         response = HealthCheckReport.class,\r
 126         responseHeaders = {\r
 127             @ResponseHeader(name = VERSION_MINOR_NAME,\r
 128                 description = VERSION_MINOR_DESCRIPTION,\r
 129                 response = String.class),\r
 130             @ResponseHeader(name = VERSION_PATCH_NAME,\r
 131                 description = VERSION_PATCH_DESCRIPTION,\r
 132                 response = String.class),\r
 133             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
 134                 response = String.class),\r
 135             @ResponseHeader(name = REQUEST_ID_NAME,\r
 136                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
 137         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"HealthCheck", },\r
 138         extensions = {\r
 139             @Extension(name = EXTENSION_NAME, properties = {\r
 140                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
 141                 @ExtensionProperty(name = LAST_MOD_NAME, value = "Dublin")})})\r
 142     @ApiResponses(value = {\r
 143         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
 144         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
 145         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)})\r
 146     public ResponseEntity<HealthCheckReport> getHealthCheck(\r
 147         @RequestHeader(name = REQUEST_ID_NAME, required = false)\r
 148         @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId) {\r
 149         updateApiStatisticsCounter(Target.OTHER, HttpStatus.OK, HttpMethod.GET);\r
 150         return makeOkResponse(requestId, healthCheckProvider.performHealthCheck());\r
 151     }\r
 152 \r
 153     /**\r
 154      * Retrieves the statistics report of the API component.\r
 155      *\r
 156      * @return the Response object containing the results of the API operation\r
 157      */\r
 158     @GetMapping("/statistics")\r
 159     @ApiOperation(value = "Retrieve current statistics",\r
 160         notes = "Returns current statistics including the counters of API invocation",\r
 161         response = StatisticsReport.class,\r
 162         responseHeaders = {\r
 163             @ResponseHeader(name = VERSION_MINOR_NAME,\r
 164                 description = VERSION_MINOR_DESCRIPTION,\r
 165                 response = String.class),\r
 166             @ResponseHeader(name = VERSION_PATCH_NAME,\r
 167                 description = VERSION_PATCH_DESCRIPTION,\r
 168                 response = String.class),\r
 169             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
 170                 response = String.class),\r
 171             @ResponseHeader(name = REQUEST_ID_NAME,\r
 172                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
 173         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"Statistics", },\r
 174         extensions = {\r
 175             @Extension(name = EXTENSION_NAME, properties = {\r
 176                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
 177                 @ExtensionProperty(name = LAST_MOD_NAME, value = "Dublin")})})\r
 178     @ApiResponses(value = {\r
 179         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
 180         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
 181         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)})\r
 182     public ResponseEntity<StatisticsReport> getStatistics(\r
 183         @RequestHeader(name = REQUEST_ID_NAME, required = false)\r
 184         @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId) {\r
 185         updateApiStatisticsCounter(Target.OTHER, HttpStatus.OK, HttpMethod.GET);\r
 186         return makeOkResponse(requestId, statisticsProvider.fetchCurrentStatistics());\r
 187     }\r
 188 \r
 189     /**\r
 190      * Retrieves all available policy types.\r
 191      *\r
 192      * @return the Response object containing the results of the API operation\r
 193      */\r
 194     @GetMapping("/policytypes")\r
 195     @ApiOperation(value = "Retrieve existing policy types",\r
 196         notes = "Returns a list of existing policy types stored in Policy Framework",\r
 197         response = ToscaServiceTemplate.class,\r
 198         responseHeaders = {\r
 199             @ResponseHeader(name = VERSION_MINOR_NAME,\r
 200                 description = VERSION_MINOR_DESCRIPTION,\r
 201                 response = String.class),\r
 202             @ResponseHeader(name = VERSION_PATCH_NAME,\r
 203                 description = VERSION_PATCH_DESCRIPTION,\r
 204                 response = String.class),\r
 205             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
 206                 response = String.class),\r
 207             @ResponseHeader(name = REQUEST_ID_NAME,\r
 208                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
 209         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"PolicyType", },\r
 210         extensions = {\r
 211             @Extension(name = EXTENSION_NAME, properties = {\r
 212                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
 213                 @ExtensionProperty(name = LAST_MOD_NAME, value = "Dublin")})})\r
 214     @ApiResponses(value = {\r
 215         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
 216         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
 217         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)})\r
 218     public ResponseEntity<ToscaServiceTemplate> getAllPolicyTypes(\r
 219         @RequestHeader(name = REQUEST_ID_NAME, required = false)\r
 220         @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId) {\r
 221         try {\r
 222             ToscaServiceTemplate serviceTemplate = policyTypeProvider.fetchPolicyTypes(null, null);\r
 223             updateApiStatisticsCounter(Target.POLICY_TYPE, HttpStatus.OK, HttpMethod.GET);\r
 224             return makeOkResponse(requestId, serviceTemplate);\r
 225         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 226             final var msg = "GET /policytypes";\r
 227             updateApiStatisticsCounter(Target.POLICY_TYPE, HttpStatus.resolve(pfme.getErrorResponse().getResponseCode()\r
 228                 .getStatusCode()), HttpMethod.GET);\r
 229             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 230         }\r
 231     }\r
 232 \r
 233     /**\r
 234      * Retrieves all versions of a particular policy type.\r
 235      *\r
 236      * @param policyTypeId the ID of specified policy type\r
 237      *\r
 238      * @return the Response object containing the results of the API operation\r
 239      */\r
 240     @GetMapping("/policytypes/{policyTypeId}")\r
 241     @ApiOperation(value = "Retrieve all available versions of a policy type",\r
 242         notes = "Returns a list of all available versions for the specified policy type",\r
 243         response = ToscaServiceTemplate.class,\r
 244         responseHeaders = {\r
 245             @ResponseHeader(name = VERSION_MINOR_NAME,\r
 246                 description = VERSION_MINOR_DESCRIPTION,\r
 247                 response = String.class),\r
 248             @ResponseHeader(name = VERSION_PATCH_NAME,\r
 249                 description = VERSION_PATCH_DESCRIPTION,\r
 250                 response = String.class),\r
 251             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
 252                 response = String.class),\r
 253             @ResponseHeader(name = REQUEST_ID_NAME,\r
 254                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
 255         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"PolicyType", },\r
 256         extensions = {\r
 257             @Extension(name = EXTENSION_NAME, properties = {\r
 258                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
 259                 @ExtensionProperty(name = LAST_MOD_NAME, value = "Dublin")})})\r
 260     @ApiResponses(value = {\r
 261         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
 262         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
 263         @ApiResponse(code = HttpURLConnection.HTTP_NOT_FOUND, message = NOT_FOUND_MESSAGE),\r
 264         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)})\r
 265     public ResponseEntity<ToscaServiceTemplate> getAllVersionsOfPolicyType(\r
 266         @PathVariable("policyTypeId") @ApiParam(value = "ID of policy type", required = true) String policyTypeId,\r
 267         @RequestHeader(name = REQUEST_ID_NAME, required = false)\r
 268         @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId) {\r
 269         try {\r
 270             ToscaServiceTemplate serviceTemplate = policyTypeProvider.fetchPolicyTypes(policyTypeId, null);\r
 271             updateApiStatisticsCounter(Target.POLICY_TYPE, HttpStatus.OK, HttpMethod.GET);\r
 272             return makeOkResponse(requestId, serviceTemplate);\r
 273         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 274             var msg = String.format("GET /policytypes/%s", policyTypeId);\r
 275             updateApiStatisticsCounter(Target.POLICY_TYPE, HttpStatus.resolve(pfme.getErrorResponse().getResponseCode()\r
 276                 .getStatusCode()), HttpMethod.GET);\r
 277             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 278         }\r
 279     }\r
 280 \r
 281     /**\r
 282      * Retrieves specified version of a particular policy type.\r
 283      *\r
 284      * @param policyTypeId the ID of specified policy type\r
 285      * @param versionId the version of specified policy type\r
 286      *\r
 287      * @return the Response object containing the results of the API operation\r
 288      */\r
 289     @GetMapping("/policytypes/{policyTypeId}/versions/{versionId}")\r
 290     @ApiOperation(value = "Retrieve one particular version of a policy type",\r
 291         notes = "Returns a particular version for the specified policy type", response = ToscaServiceTemplate.class,\r
 292         responseHeaders = {\r
 293             @ResponseHeader(name = VERSION_MINOR_NAME,\r
 294                 description = VERSION_MINOR_DESCRIPTION,\r
 295                 response = String.class),\r
 296             @ResponseHeader(name = VERSION_PATCH_NAME,\r
 297                 description = VERSION_PATCH_DESCRIPTION,\r
 298                 response = String.class),\r
 299             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
 300                 response = String.class),\r
 301             @ResponseHeader(name = REQUEST_ID_NAME,\r
 302                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
 303         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"PolicyType", },\r
 304         extensions = {\r
 305             @Extension(name = EXTENSION_NAME, properties = {\r
 306                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
 307                 @ExtensionProperty(name = LAST_MOD_NAME, value = "Dublin")})})\r
 308     @ApiResponses(value = {\r
 309         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
 310         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
 311         @ApiResponse(code = HttpURLConnection.HTTP_NOT_FOUND, message = NOT_FOUND_MESSAGE),\r
 312         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)})\r
 313     public ResponseEntity<ToscaServiceTemplate> getSpecificVersionOfPolicyType(\r
 314         @PathVariable("policyTypeId") @ApiParam(value = "ID of policy type", required = true) String policyTypeId,\r
 315         @PathVariable("versionId") @ApiParam(value = "Version of policy type", required = true) String versionId,\r
 316         @RequestHeader(name = REQUEST_ID_NAME, required = false)\r
 317         @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId) {\r
 318         try {\r
 319             ToscaServiceTemplate serviceTemplate = policyTypeProvider.fetchPolicyTypes(policyTypeId, versionId);\r
 320             updateApiStatisticsCounter(Target.POLICY_TYPE, HttpStatus.OK, HttpMethod.GET);\r
 321             return makeOkResponse(requestId, serviceTemplate);\r
 322         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 323             var msg = String.format("GET /policytypes/%s/versions/%s", policyTypeId, versionId);\r
 324             updateApiStatisticsCounter(Target.POLICY_TYPE, HttpStatus.resolve(pfme.getErrorResponse().getResponseCode()\r
 325                 .getStatusCode()), HttpMethod.GET);\r
 326             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 327         }\r
 328     }\r
 329 \r
 330     /**\r
 331      * Retrieves latest version of a particular policy type.\r
 332      *\r
 333      * @param policyTypeId the ID of specified policy type\r
 334      *\r
 335      * @return the Response object containing the results of the API operation\r
 336      */\r
 337     @GetMapping("/policytypes/{policyTypeId}/versions/latest")\r
 338     @ApiOperation(value = "Retrieve latest version of a policy type",\r
 339         notes = "Returns latest version for the specified policy type", response = ToscaServiceTemplate.class,\r
 340         responseHeaders = {\r
 341             @ResponseHeader(name = VERSION_MINOR_NAME,\r
 342                 description = VERSION_MINOR_DESCRIPTION,\r
 343                 response = String.class),\r
 344             @ResponseHeader(name = VERSION_PATCH_NAME,\r
 345                 description = VERSION_PATCH_DESCRIPTION,\r
 346                 response = String.class),\r
 347             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
 348                 response = String.class),\r
 349             @ResponseHeader(name = REQUEST_ID_NAME,\r
 350                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
 351         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"PolicyType", },\r
 352         extensions = {\r
 353             @Extension(name = EXTENSION_NAME, properties = {\r
 354                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
 355                 @ExtensionProperty(name = LAST_MOD_NAME, value = "Dublin")})})\r
 356     @ApiResponses(value = {\r
 357         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
 358         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
 359         @ApiResponse(code = HttpURLConnection.HTTP_NOT_FOUND, message = NOT_FOUND_MESSAGE),\r
 360         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)})\r
 361     public ResponseEntity<ToscaServiceTemplate> getLatestVersionOfPolicyType(\r
 362         @PathVariable("policyTypeId") @ApiParam(value = "ID of policy type", required = true) String policyTypeId,\r
 363         @RequestHeader(name = REQUEST_ID_NAME, required = false)\r
 364         @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId) {\r
 365         try {\r
 366             ToscaServiceTemplate serviceTemplate = policyTypeProvider.fetchLatestPolicyTypes(policyTypeId);\r
 367             updateApiStatisticsCounter(Target.POLICY_TYPE, HttpStatus.OK, HttpMethod.GET);\r
 368             return makeOkResponse(requestId, serviceTemplate);\r
 369         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 370             var msg = String.format("GET /policytypes/%s/versions/latest", policyTypeId);\r
 371             updateApiStatisticsCounter(Target.POLICY_TYPE, HttpStatus.resolve(pfme.getErrorResponse().getResponseCode()\r
 372                 .getStatusCode()), HttpMethod.GET);\r
 373             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 374         }\r
 375     }\r
 376 \r
 377     /**\r
 378      * Creates a new policy type.\r
 379      *\r
 380      * @param body the body of policy type following TOSCA definition\r
 381      *\r
 382      * @return the Response object containing the results of the API operation\r
 383      */\r
 384     @PostMapping("/policytypes")\r
 385     @ApiOperation(value = "Create a new policy type", notes = "Client should provide TOSCA body of the new policy type",\r
 386         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"PolicyType", },\r
 387         response = ToscaServiceTemplate.class,\r
 388         responseHeaders = {\r
 389             @ResponseHeader(name = VERSION_MINOR_NAME,\r
 390                 description = VERSION_MINOR_DESCRIPTION,\r
 391                 response = String.class),\r
 392             @ResponseHeader(name = VERSION_PATCH_NAME,\r
 393                 description = VERSION_PATCH_DESCRIPTION,\r
 394                 response = String.class),\r
 395             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
 396                 response = String.class),\r
 397             @ResponseHeader(name = REQUEST_ID_NAME,\r
 398                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
 399         extensions = {\r
 400             @Extension(name = EXTENSION_NAME, properties = {\r
 401                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
 402                 @ExtensionProperty(name = LAST_MOD_NAME, value = "Dublin")})})\r
 403     @ApiResponses(value = {\r
 404         @ApiResponse(code = HttpURLConnection.HTTP_BAD_REQUEST, message = INVALID_BODY_MESSAGE),\r
 405         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
 406         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
 407         @ApiResponse(code = HttpURLConnection.HTTP_NOT_ACCEPTABLE, message = INVALID_PAYLOAD_MESSAGE),\r
 408         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)})\r
 409     public ResponseEntity<ToscaServiceTemplate> createPolicyType(\r
 410         @RequestBody @ApiParam(value = "Entity body of policy type", required = true) ToscaServiceTemplate body,\r
 411         @RequestHeader(name = REQUEST_ID_NAME, required = false)\r
 412         @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId) {\r
 413         if (NetLoggerUtil.getNetworkLogger().isInfoEnabled()) {\r
 414             NetLoggerUtil.log(EventType.IN, CommInfrastructure.REST, "/policytypes", toJson(body));\r
 415         }\r
 416         try {\r
 417             ToscaServiceTemplate serviceTemplate = policyTypeProvider.createPolicyType(body);\r
 418             updateApiStatisticsCounter(Target.POLICY_TYPE, HttpStatus.OK, HttpMethod.POST);\r
 419             return makeOkResponse(requestId, serviceTemplate);\r
 420         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 421             final var msg = "POST /policytypes";\r
 422             updateApiStatisticsCounter(Target.POLICY_TYPE, HttpStatus.resolve(pfme.getErrorResponse().getResponseCode()\r
 423                 .getStatusCode()), HttpMethod.POST);\r
 424             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 425         }\r
 426     }\r
 427 \r
 428     /**\r
 429      * Deletes specified version of a particular policy type.\r
 430      *\r
 431      * @param policyTypeId the ID of specified policy type\r
 432      * @param versionId the version of specified policy type\r
 433      *\r
 434      * @return the Response object containing the results of the API operation\r
 435      */\r
 436     @DeleteMapping("/policytypes/{policyTypeId}/versions/{versionId}")\r
 437     @ApiOperation(value = "Delete one version of a policy type",\r
 438         notes = "Rule 1: pre-defined policy types cannot be deleted;"\r
 439             + "Rule 2: policy types that are in use (parameterized by a TOSCA policy) cannot be deleted."\r
 440             + "The parameterizing TOSCA policies must be deleted first;",\r
 441         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"PolicyType", },\r
 442         response = ToscaServiceTemplate.class,\r
 443         responseHeaders = {\r
 444             @ResponseHeader(name = VERSION_MINOR_NAME,\r
 445                 description = VERSION_MINOR_DESCRIPTION,\r
 446                 response = String.class),\r
 447             @ResponseHeader(name = VERSION_PATCH_NAME,\r
 448                 description = VERSION_PATCH_DESCRIPTION,\r
 449                 response = String.class),\r
 450             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
 451                 response = String.class),\r
 452             @ResponseHeader(name = REQUEST_ID_NAME,\r
 453                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
 454         extensions = {\r
 455             @Extension(name = EXTENSION_NAME, properties = {\r
 456                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
 457                 @ExtensionProperty(name = LAST_MOD_NAME, value = "Dublin")})})\r
 458     @ApiResponses(value = {\r
 459         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
 460         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
 461         @ApiResponse(code = HttpURLConnection.HTTP_NOT_FOUND, message = NOT_FOUND_MESSAGE),\r
 462         @ApiResponse(code = HttpURLConnection.HTTP_CONFLICT, message = HTTP_CONFLICT_MESSAGE),\r
 463         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)})\r
 464     public ResponseEntity<ToscaServiceTemplate> deleteSpecificVersionOfPolicyType(\r
 465         @PathVariable("policyTypeId") @ApiParam(value = "ID of policy type", required = true) String policyTypeId,\r
 466         @PathVariable("versionId") @ApiParam(value = "Version of policy type", required = true) String versionId,\r
 467         @RequestHeader(name = REQUEST_ID_NAME, required = false)\r
 468         @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId) {\r
 469         try {\r
 470             ToscaServiceTemplate serviceTemplate = policyTypeProvider.deletePolicyType(policyTypeId, versionId);\r
 471             updateApiStatisticsCounter(Target.POLICY_TYPE, HttpStatus.OK, HttpMethod.DELETE);\r
 472             return makeOkResponse(requestId, serviceTemplate);\r
 473         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 474             var msg = String.format("DELETE /policytypes/%s/versions/%s", policyTypeId, versionId);\r
 475             updateApiStatisticsCounter(Target.POLICY_TYPE, HttpStatus.resolve(pfme.getErrorResponse().getResponseCode()\r
 476                 .getStatusCode()), HttpMethod.DELETE);\r
 477             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 478         }\r
 479     }\r
 480 \r
 481     /**\r
 482      * Retrieves all versions of a particular policy.\r
 483      *\r
 484      * @param policyTypeId the ID of specified policy type\r
 485      * @param policyTypeVersion the version of specified policy type\r
 486      *\r
 487      * @return the Response object containing the results of the API operation\r
 488      */\r
 489     @GetMapping("/policytypes/{policyTypeId}/versions/{policyTypeVersion}/policies")\r
 490     @ApiOperation(\r
 491         value = "Retrieve all versions of a policy created for a particular policy type version",\r
 492         notes = "Returns a list of all versions of specified policy created for the specified policy type version",\r
 493         response = ToscaServiceTemplate.class,\r
 494         responseHeaders = {\r
 495             @ResponseHeader(name = VERSION_MINOR_NAME,\r
 496                 description = VERSION_MINOR_DESCRIPTION,\r
 497                 response = String.class),\r
 498             @ResponseHeader(name = VERSION_PATCH_NAME,\r
 499                 description = VERSION_PATCH_DESCRIPTION,\r
 500                 response = String.class),\r
 501             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
 502                 response = String.class),\r
 503             @ResponseHeader(name = REQUEST_ID_NAME,\r
 504                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
 505         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"Policy,"},\r
 506         extensions = {\r
 507             @Extension(name = EXTENSION_NAME, properties = {\r
 508                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
 509                 @ExtensionProperty(name = LAST_MOD_NAME, value = "Dublin")\r
 510             })\r
 511         }\r
 512     )\r
 513     @ApiResponses(value = {\r
 514         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
 515         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
 516         @ApiResponse(code = HttpURLConnection.HTTP_NOT_FOUND, message = NOT_FOUND_MESSAGE),\r
 517         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)\r
 518     })\r
 519     public ResponseEntity<ToscaServiceTemplate> getAllPolicies(\r
 520         @PathVariable("policyTypeId") @ApiParam(value = "ID of policy type", required = true) String policyTypeId,\r
 521         @PathVariable("policyTypeVersion") @ApiParam(value = "Version of policy type",\r
 522             required = true) String policyTypeVersion,\r
 523         @RequestHeader(name = REQUEST_ID_NAME, required = false)\r
 524         @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId,\r
 525         @RequestParam(name = "mode", defaultValue = "bare") @ApiParam("Fetch mode for policies, BARE for bare"\r
 526             + " policies (default), REFERENCED for fully referenced policies") PolicyFetchMode mode) {\r
 527         try {\r
 528             ToscaServiceTemplate serviceTemplate =\r
 529                 policyProvider.fetchPolicies(policyTypeId, policyTypeVersion, null, null, mode);\r
 530             updateApiStatisticsCounter(Target.POLICY, HttpStatus.OK, HttpMethod.GET);\r
 531             return makeOkResponse(requestId, serviceTemplate);\r
 532         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 533             var msg = String.format("GET /policytypes/%s/versions/%s/policies", policyTypeId, policyTypeVersion);\r
 534             updateApiStatisticsCounter(Target.POLICY, HttpStatus.resolve(pfme.getErrorResponse().getResponseCode()\r
 535                 .getStatusCode()), HttpMethod.GET);\r
 536             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 537         }\r
 538     }\r
 539 \r
 540     /**\r
 541      * Retrieves all versions of a particular policy.\r
 542      *\r
 543      * @param policyTypeId the ID of specified policy type\r
 544      * @param policyTypeVersion the version of specified policy type\r
 545      * @param policyId the ID of specified policy\r
 546      *\r
 547      * @return the Response object containing the results of the API operation\r
 548      */\r
 549     @GetMapping("/policytypes/{policyTypeId}/versions/{policyTypeVersion}/policies/{policyId}")\r
 550     @ApiOperation(value = "Retrieve all version details of a policy created for a particular policy type version",\r
 551         notes = "Returns a list of all version details of the specified policy", response = ToscaServiceTemplate.class,\r
 552         responseHeaders = {\r
 553             @ResponseHeader(name = VERSION_MINOR_NAME,\r
 554                 description = VERSION_MINOR_DESCRIPTION,\r
 555                 response = String.class),\r
 556             @ResponseHeader(name = VERSION_PATCH_NAME,\r
 557                 description = VERSION_PATCH_DESCRIPTION,\r
 558                 response = String.class),\r
 559             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
 560                 response = String.class),\r
 561             @ResponseHeader(name = REQUEST_ID_NAME,\r
 562                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
 563         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"Policy", },\r
 564         extensions = {\r
 565             @Extension(name = EXTENSION_NAME, properties = {\r
 566                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
 567                 @ExtensionProperty(name = LAST_MOD_NAME, value = "Dublin")\r
 568             })\r
 569         }\r
 570     )\r
 571     @ApiResponses(value = {\r
 572         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
 573         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
 574         @ApiResponse(code = HttpURLConnection.HTTP_NOT_FOUND, message = NOT_FOUND_MESSAGE),\r
 575         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)\r
 576     })\r
 577     public ResponseEntity<ToscaServiceTemplate> getAllVersionsOfPolicy(\r
 578         @PathVariable("policyTypeId") @ApiParam(value = "ID of policy type", required = true) String policyTypeId,\r
 579         @PathVariable("policyTypeVersion") @ApiParam(value = "Version of policy type",\r
 580             required = true) String policyTypeVersion,\r
 581         @PathVariable("policyId") @ApiParam(value = "ID of policy", required = true) String policyId,\r
 582         @RequestHeader(name = REQUEST_ID_NAME, required = false) @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId,\r
 583         @RequestParam(name = "mode", defaultValue = "bare")\r
 584         @ApiParam("Fetch mode for policies, BARE for bare policies (default),"\r
 585             + " REFERENCED for fully referenced policies") PolicyFetchMode mode) {\r
 586         try {\r
 587             ToscaServiceTemplate serviceTemplate =\r
 588                 policyProvider.fetchPolicies(policyTypeId, policyTypeVersion, policyId, null, mode);\r
 589             updateApiStatisticsCounter(Target.POLICY, HttpStatus.OK, HttpMethod.GET);\r
 590             return makeOkResponse(requestId, serviceTemplate);\r
 591         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 592             var msg = String.format("/policytypes/%s/versions/$s/policies/%s",\r
 593                 policyTypeId, policyTypeVersion, policyId);\r
 594             updateApiStatisticsCounter(Target.POLICY, HttpStatus.resolve(pfme.getErrorResponse().getResponseCode()\r
 595                 .getStatusCode()), HttpMethod.GET);\r
 596             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 597         }\r
 598     }\r
 599 \r
 600     /**\r
 601      * Retrieves the specified version of a particular policy.\r
 602      *\r
 603      * @param policyTypeId the ID of specified policy type\r
 604      * @param policyTypeVersion the version of specified policy type\r
 605      * @param policyId the ID of specified policy\r
 606      * @param policyVersion the version of specified policy\r
 607      *\r
 608      * @return the Response object containing the results of the API operation\r
 609      */\r
 610     @GetMapping("/policytypes/{policyTypeId}/versions/{policyTypeVersion}/policies/{policyId}/versions/{policyVersion}")\r
 611     @ApiOperation(value = "Retrieve one version of a policy created for a particular policy type version",\r
 612         notes = "Returns a particular version of specified policy created for the specified policy type version",\r
 613         response = ToscaServiceTemplate.class,\r
 614         responseHeaders = {\r
 615             @ResponseHeader(name = VERSION_MINOR_NAME,\r
 616                 description = VERSION_MINOR_DESCRIPTION,\r
 617                 response = String.class),\r
 618             @ResponseHeader(name = VERSION_PATCH_NAME,\r
 619                 description = VERSION_PATCH_DESCRIPTION,\r
 620                 response = String.class),\r
 621             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
 622                 response = String.class),\r
 623             @ResponseHeader(name = REQUEST_ID_NAME,\r
 624                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
 625         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"Policy", },\r
 626         extensions = {\r
 627             @Extension(name = EXTENSION_NAME, properties = {\r
 628                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
 629                 @ExtensionProperty(name = LAST_MOD_NAME, value = "Dublin")\r
 630             })\r
 631         }\r
 632     )\r
 633     @ApiResponses(value = {\r
 634         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
 635         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
 636         @ApiResponse(code = HttpURLConnection.HTTP_NOT_FOUND, message = NOT_FOUND_MESSAGE),\r
 637         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)\r
 638     })\r
 639     public ResponseEntity<ToscaServiceTemplate> getSpecificVersionOfPolicy(\r
 640         @PathVariable("policyTypeId") @ApiParam(value = "ID of policy type", required = true) String policyTypeId,\r
 641         @PathVariable("policyTypeVersion") @ApiParam(value = "Version of policy type",\r
 642             required = true) String policyTypeVersion,\r
 643         @PathVariable("policyId") @ApiParam(value = "ID of policy", required = true) String policyId,\r
 644         @PathVariable("policyVersion") @ApiParam(value = "Version of policy", required = true) String policyVersion,\r
 645         @RequestHeader(name = REQUEST_ID_NAME, required = false)\r
 646         @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId,\r
 647         @RequestParam(name = "mode", defaultValue = "bare") @ApiParam("Fetch mode for policies, BARE for bare policies"\r
 648             + "  (default), REFERENCED for fully referenced policies") PolicyFetchMode mode) {\r
 649         try {\r
 650             ToscaServiceTemplate serviceTemplate =\r
 651                 policyProvider.fetchPolicies(policyTypeId, policyTypeVersion, policyId, policyVersion, mode);\r
 652             updateApiStatisticsCounter(Target.POLICY, HttpStatus.OK, HttpMethod.GET);\r
 653             return makeOkResponse(requestId, serviceTemplate);\r
 654         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 655             var msg = String.format("GET /policytypes/%s/versions/%s/policies/%s/versions/%s",\r
 656                 policyTypeId, policyTypeVersion, policyId, policyVersion);\r
 657             updateApiStatisticsCounter(Target.POLICY, HttpStatus.resolve(pfme.getErrorResponse().getResponseCode()\r
 658                 .getStatusCode()), HttpMethod.GET);\r
 659             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 660         }\r
 661     }\r
 662 \r
 663     /**\r
 664      * Retrieves the latest version of a particular policy.\r
 665      *\r
 666      * @param policyTypeId the ID of specified policy type\r
 667      * @param policyTypeVersion the version of specified policy type\r
 668      * @param policyId the ID of specified policy\r
 669      *\r
 670      * @return the Response object containing the results of the API operation\r
 671      */\r
 672     @GetMapping("/policytypes/{policyTypeId}/versions/{policyTypeVersion}/policies/{policyId}/versions/latest")\r
 673     @ApiOperation(value = "Retrieve the latest version of a particular policy",\r
 674         notes = "Returns the latest version of specified policy", response = ToscaServiceTemplate.class,\r
 675         responseHeaders = {\r
 676             @ResponseHeader(name = VERSION_MINOR_NAME,\r
 677                 description = VERSION_MINOR_DESCRIPTION,\r
 678                 response = String.class),\r
 679             @ResponseHeader(name = VERSION_PATCH_NAME,\r
 680                 description = VERSION_PATCH_DESCRIPTION,\r
 681                 response = String.class),\r
 682             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
 683                 response = String.class),\r
 684             @ResponseHeader(name = REQUEST_ID_NAME,\r
 685                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
 686         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"Policy", },\r
 687         extensions = {\r
 688             @Extension(name = EXTENSION_NAME, properties = {\r
 689                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
 690                 @ExtensionProperty(name = LAST_MOD_NAME, value = "Dublin")})})\r
 691     @ApiResponses(value = {\r
 692         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
 693         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
 694         @ApiResponse(code = HttpURLConnection.HTTP_NOT_FOUND, message = NOT_FOUND_MESSAGE),\r
 695         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)})\r
 696     public ResponseEntity<ToscaServiceTemplate> getLatestVersionOfPolicy(\r
 697         @PathVariable("policyTypeId") @ApiParam(value = "ID of policy type", required = true) String policyTypeId,\r
 698         @PathVariable("policyTypeVersion") @ApiParam(value = "Version of policy type",\r
 699             required = true) String policyTypeVersion,\r
 700         @PathVariable("policyId") @ApiParam(value = "ID of policy", required = true) String policyId,\r
 701         @RequestHeader(name = REQUEST_ID_NAME, required = false)\r
 702         @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId,\r
 703         @RequestParam(name = "mode", defaultValue = "bare") @ApiParam("Fetch mode for policies, TERSE for bare "\r
 704             + "policies (default), REFERENCED for fully referenced policies") PolicyFetchMode mode) {\r
 705         try {\r
 706             ToscaServiceTemplate serviceTemplate =\r
 707                 policyProvider.fetchLatestPolicies(policyTypeId, policyTypeVersion, policyId, mode);\r
 708             updateApiStatisticsCounter(Target.POLICY, HttpStatus.OK, HttpMethod.GET);\r
 709             return makeOkResponse(requestId, serviceTemplate);\r
 710         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 711             var msg = String.format("GET /policytypes/%s/versions/%s/policies/%s/versions/latest",\r
 712                 policyTypeId, policyTypeVersion, policyId);\r
 713             updateApiStatisticsCounter(Target.POLICY, HttpStatus.resolve(pfme.getErrorResponse().getResponseCode()\r
 714                 .getStatusCode()), HttpMethod.GET);\r
 715             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 716         }\r
 717     }\r
 718 \r
 719     /**\r
 720      * Creates a new policy for a particular policy type and version.\r
 721      *\r
 722      * @param policyTypeId the ID of specified policy type\r
 723      * @param policyTypeVersion the version of specified policy type\r
 724      * @param body the body of policy following TOSCA definition\r
 725      *\r
 726      * @return the Response object containing the results of the API operation\r
 727      */\r
 728     @PostMapping("/policytypes/{policyTypeId}/versions/{policyTypeVersion}/policies")\r
 729     @ApiOperation(value = "Create a new policy for a policy type version",\r
 730         notes = "Client should provide TOSCA body of the new policy",\r
 731         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"Policy", },\r
 732             response = ToscaServiceTemplate.class,\r
 733         responseHeaders = {\r
 734             @ResponseHeader(name = VERSION_MINOR_NAME,\r
 735                 description = VERSION_MINOR_DESCRIPTION,\r
 736                 response = String.class),\r
 737             @ResponseHeader(name = VERSION_PATCH_NAME,\r
 738                 description = VERSION_PATCH_DESCRIPTION,\r
 739                 response = String.class),\r
 740             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
 741                 response = String.class),\r
 742             @ResponseHeader(name = REQUEST_ID_NAME,\r
 743                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
 744         extensions = {\r
 745             @Extension(name = EXTENSION_NAME, properties = {\r
 746                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
 747                 @ExtensionProperty(name = LAST_MOD_NAME, value = "Dublin")})})\r
 748     @ApiResponses(value = {\r
 749         @ApiResponse(code = HttpURLConnection.HTTP_BAD_REQUEST, message = INVALID_BODY_MESSAGE),\r
 750         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
 751         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
 752         @ApiResponse(code = HttpURLConnection.HTTP_NOT_FOUND, message = NOT_FOUND_MESSAGE),\r
 753         @ApiResponse(code = HttpURLConnection.HTTP_NOT_ACCEPTABLE, message = INVALID_PAYLOAD_MESSAGE),\r
 754         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)})\r
 755     public ResponseEntity<ToscaServiceTemplate> createPolicy(\r
 756         @PathVariable("policyTypeId") @ApiParam(value = "ID of policy type", required = true) String policyTypeId,\r
 757         @PathVariable("policyTypeVersion") @ApiParam(value = "Version of policy type",\r
 758             required = true) String policyTypeVersion,\r
 759         @RequestHeader(name = REQUEST_ID_NAME, required = false)\r
 760         @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId,\r
 761         @RequestBody @ApiParam(value = "Entity body of policy", required = true) ToscaServiceTemplate body) {\r
 762         if (NetLoggerUtil.getNetworkLogger().isInfoEnabled()) {\r
 763             NetLoggerUtil.log(EventType.IN, CommInfrastructure.REST,\r
 764                 "/policytypes/" + policyTypeId + "/versions/" + policyTypeVersion + "/policies", toJson(body));\r
 765         }\r
 766         try {\r
 767             ToscaServiceTemplate serviceTemplate = policyProvider.createPolicy(policyTypeId, policyTypeVersion, body);\r
 768             updateApiStatisticsCounter(Target.POLICY, HttpStatus.OK, HttpMethod.POST);\r
 769             return makeOkResponse(requestId, serviceTemplate);\r
 770         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 771             var msg = String.format("POST /policytypes/%s/versions/%s/policies", policyTypeId, policyTypeVersion);\r
 772             updateApiStatisticsCounter(Target.POLICY, HttpStatus.resolve(pfme.getErrorResponse().getResponseCode()\r
 773                 .getStatusCode()), HttpMethod.POST);\r
 774             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 775         }\r
 776     }\r
 777 \r
 778     /**\r
 779      * Deletes the specified version of a particular policy.\r
 780      *\r
 781      * @param policyTypeId the ID of specified policy type\r
 782      * @param policyTypeVersion the version of specified policy type\r
 783      * @param policyId the ID of specified policy\r
 784      * @param policyVersion the version of specified policy\r
 785      *\r
 786      * @return the Response object containing the results of the API operation\r
 787      */\r
 788     @DeleteMapping("/policytypes/{policyTypeId}/versions/{policyTypeVersion}/policies/{policyId}/"\r
 789         + "versions/{policyVersion}")\r
 790     @ApiOperation(value = "Delete a particular version of a policy",\r
 791         notes = "Rule: the version that has been deployed in PDP group(s) cannot be deleted",\r
 792         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"Policy", },\r
 793         response = ToscaServiceTemplate.class,\r
 794         responseHeaders = {\r
 795             @ResponseHeader(name = VERSION_MINOR_NAME,\r
 796                 description = VERSION_MINOR_DESCRIPTION,\r
 797                 response = String.class),\r
 798             @ResponseHeader(name = VERSION_PATCH_NAME,\r
 799                 description = VERSION_PATCH_DESCRIPTION,\r
 800                 response = String.class),\r
 801             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
 802                 response = String.class),\r
 803             @ResponseHeader(name = REQUEST_ID_NAME,\r
 804                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
 805         extensions = {\r
 806             @Extension(name = EXTENSION_NAME, properties = {\r
 807                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
 808                 @ExtensionProperty(name = LAST_MOD_NAME, value = "Dublin")})})\r
 809     @ApiResponses(value = {\r
 810         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
 811         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
 812         @ApiResponse(code = HttpURLConnection.HTTP_NOT_FOUND, message = NOT_FOUND_MESSAGE),\r
 813         @ApiResponse(code = HttpURLConnection.HTTP_CONFLICT, message = HTTP_CONFLICT_MESSAGE),\r
 814         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)})\r
 815     public ResponseEntity<ToscaServiceTemplate> deleteSpecificVersionOfPolicy(\r
 816         @PathVariable("policyTypeId") @ApiParam(value = "PolicyType ID", required = true) String policyTypeId,\r
 817         @PathVariable("policyTypeVersion") @ApiParam(value = "Version of policy type",\r
 818             required = true) String policyTypeVersion,\r
 819         @PathVariable("policyId") @ApiParam(value = "ID of policy", required = true) String policyId,\r
 820         @PathVariable("policyVersion") @ApiParam(value = "Version of policy", required = true) String policyVersion,\r
 821         @RequestHeader(name = REQUEST_ID_NAME, required = false)\r
 822         @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId) {\r
 823         try {\r
 824             ToscaServiceTemplate serviceTemplate =\r
 825                 policyProvider.deletePolicy(policyTypeId, policyTypeVersion, policyId, policyVersion);\r
 826             updateApiStatisticsCounter(Target.POLICY, HttpStatus.OK, HttpMethod.DELETE);\r
 827             return makeOkResponse(requestId, serviceTemplate);\r
 828         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 829             var msg = String.format("DELETE /policytypes/%s/versions/%s/policies/%s/versions/%s",\r
 830                 policyTypeId, policyTypeVersion, policyId, policyVersion);\r
 831             updateApiStatisticsCounter(Target.POLICY, HttpStatus.resolve(pfme.getErrorResponse().getResponseCode()\r
 832                 .getStatusCode()), HttpMethod.DELETE);\r
 833             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 834         }\r
 835     }\r
 836 \r
 837     /**\r
 838      * Retrieves all the available policies.\r
 839      *\r
 840      * @return the Response object containing the results of the API operation\r
 841      */\r
 842     @GetMapping("/policies")\r
 843     @ApiOperation(value = "Retrieve all versions of available policies",\r
 844         notes = "Returns all version of available policies",\r
 845         response = ToscaServiceTemplate.class,\r
 846         responseHeaders = {\r
 847             @ResponseHeader(name = VERSION_MINOR_NAME,\r
 848                 description = VERSION_MINOR_DESCRIPTION,\r
 849                 response = String.class),\r
 850             @ResponseHeader(name = VERSION_PATCH_NAME,\r
 851                 description = VERSION_PATCH_DESCRIPTION,\r
 852                 response = String.class),\r
 853             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
 854                 response = String.class),\r
 855             @ResponseHeader(name = REQUEST_ID_NAME,\r
 856                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
 857         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"Policy", },\r
 858         extensions = {\r
 859             @Extension(name = EXTENSION_NAME, properties = {\r
 860                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
 861                 @ExtensionProperty(name = LAST_MOD_NAME, value = "Guilin")\r
 862             })\r
 863         }\r
 864     )\r
 865     @ApiResponses(value = {\r
 866         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
 867         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
 868         @ApiResponse(code = HttpURLConnection.HTTP_NOT_FOUND, message = NOT_FOUND_MESSAGE),\r
 869         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)\r
 870     })\r
 871     public ResponseEntity<ToscaServiceTemplate> getPolicies(\r
 872         @RequestHeader(name = REQUEST_ID_NAME, required = false)\r
 873         @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId,\r
 874         @RequestParam(name = "mode", defaultValue = "bare") @ApiParam("Fetch mode for policies, BARE for bare"\r
 875             + "  policies (default), REFERENCED for fully referenced policies") PolicyFetchMode mode) {\r
 876         try {\r
 877             ToscaServiceTemplate serviceTemplate =\r
 878                 policyProvider.fetchPolicies(null, null, null, null, mode);\r
 879             updateApiStatisticsCounter(Target.POLICY, HttpStatus.OK, HttpMethod.GET);\r
 880             return makeOkResponse(requestId, serviceTemplate);\r
 881         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 882             final var msg = "GET /policies/ --";\r
 883             updateApiStatisticsCounter(Target.POLICY, HttpStatus.resolve(pfme.getErrorResponse().getResponseCode()\r
 884                 .getStatusCode()), HttpMethod.GET);\r
 885             if (pfme.getErrorResponse().getResponseCode().equals(Status.NOT_FOUND)) {\r
 886                 pfme.getErrorResponse().setErrorMessage(ERROR_MESSAGE_NO_POLICIES_FOUND);\r
 887                 pfme.getErrorResponse().setErrorDetails(List.of(ERROR_MESSAGE_NO_POLICIES_FOUND));\r
 888             }\r
 889             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 890         }\r
 891     }\r
 892 \r
 893     /**\r
 894      * Retrieves the specified version of a particular policy.\r
 895      *\r
 896      * @param policyId the Name of specified policy\r
 897      * @param policyVersion the version of specified policy\r
 898      *\r
 899      * @return the Response object containing the results of the API operation\r
 900      */\r
 901     @GetMapping("/policies/{policyId}/versions/{policyVersion}")\r
 902     @ApiOperation(value = "Retrieve specific version of a specified policy",\r
 903         notes = "Returns a particular version of specified policy",\r
 904         response = ToscaServiceTemplate.class,\r
 905         responseHeaders = {\r
 906             @ResponseHeader(name = VERSION_MINOR_NAME,\r
 907                 description = VERSION_MINOR_DESCRIPTION,\r
 908                 response = String.class),\r
 909             @ResponseHeader(name = VERSION_PATCH_NAME,\r
 910                 description = VERSION_PATCH_DESCRIPTION,\r
 911                 response = String.class),\r
 912             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
 913                 response = String.class),\r
 914             @ResponseHeader(name = REQUEST_ID_NAME,\r
 915                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
 916         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"Policy", },\r
 917         extensions = {\r
 918             @Extension(name = EXTENSION_NAME, properties = {\r
 919                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
 920                 @ExtensionProperty(name = LAST_MOD_NAME, value = "Guilin")\r
 921             })\r
 922         }\r
 923     )\r
 924     @ApiResponses(value = {\r
 925         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
 926         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
 927         @ApiResponse(code = HttpURLConnection.HTTP_NOT_FOUND, message = NOT_FOUND_MESSAGE),\r
 928         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)\r
 929     })\r
 930     public ResponseEntity<ToscaServiceTemplate> getSpecificPolicy(\r
 931         @PathVariable("policyId") @ApiParam(value = "Name of policy", required = true) String policyId,\r
 932         @PathVariable("policyVersion") @ApiParam(value = "Version of policy", required = true) String policyVersion,\r
 933         @RequestHeader(name = REQUEST_ID_NAME, required = false)\r
 934         @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId,\r
 935         @RequestParam(name = "mode", defaultValue = "bare") @ApiParam("Fetch mode for policies, BARE for bare"\r
 936             + "  policies (default), REFERENCED for fully referenced policies") PolicyFetchMode mode) {\r
 937         try {\r
 938             ToscaServiceTemplate serviceTemplate =\r
 939                 policyProvider.fetchPolicies(null, null, policyId, policyVersion, mode);\r
 940             updateApiStatisticsCounter(Target.POLICY, HttpStatus.OK, HttpMethod.GET);\r
 941             return makeOkResponse(requestId, serviceTemplate);\r
 942         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 943             var msg = String.format("GET /policies/%s/versions/%s", policyId, policyVersion);\r
 944             updateApiStatisticsCounter(Target.POLICY, HttpStatus.resolve(pfme.getErrorResponse().getResponseCode()\r
 945                 .getStatusCode()), HttpMethod.GET);\r
 946             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
 947         }\r
 948     }\r
 949 \r
 950     /**\r
 951      * Creates one or more new policies in one call.\r
 952      *\r
 953      * @param body the body of policy following TOSCA definition\r
 954      *\r
 955      * @return the Response object containing the results of the API operation\r
 956      */\r
 957     @PostMapping("/policies")\r
 958     @ApiOperation(value = "Create one or more new policies",\r
 959         notes = "Client should provide TOSCA body of the new polic(ies)",\r
 960         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"Policy", },\r
 961             response = ToscaServiceTemplate.class,\r
 962         responseHeaders = {\r
 963             @ResponseHeader(name = VERSION_MINOR_NAME,\r
 964                 description = VERSION_MINOR_DESCRIPTION,\r
 965                 response = String.class),\r
 966             @ResponseHeader(name = VERSION_PATCH_NAME,\r
 967                 description = VERSION_PATCH_DESCRIPTION,\r
 968                 response = String.class),\r
 969             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
 970                 response = String.class),\r
 971             @ResponseHeader(name = REQUEST_ID_NAME,\r
 972                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
 973         extensions = {\r
 974             @Extension(name = EXTENSION_NAME, properties = {\r
 975                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
 976                 @ExtensionProperty(name = LAST_MOD_NAME, value = "El Alto")})})\r
 977     @ApiResponses(value = {\r
 978         @ApiResponse(code = HttpURLConnection.HTTP_BAD_REQUEST, message = INVALID_BODY_MESSAGE),\r
 979         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
 980         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
 981         @ApiResponse(code = HttpURLConnection.HTTP_NOT_FOUND, message = NOT_FOUND_MESSAGE),\r
 982         @ApiResponse(code = HttpURLConnection.HTTP_NOT_ACCEPTABLE, message = INVALID_PAYLOAD_MESSAGE),\r
 983         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)})\r
 984     public ResponseEntity<ToscaServiceTemplate> createPolicies(\r
 985         @RequestHeader(name = REQUEST_ID_NAME, required = false)\r
 986         @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId,\r
 987         @RequestBody @ApiParam(value = "Entity body of policy", required = true) ToscaServiceTemplate body) {\r
 988         if (NetLoggerUtil.getNetworkLogger().isInfoEnabled()) {\r
 989             NetLoggerUtil.log(EventType.IN, CommInfrastructure.REST, "/policies", toJson(body));\r
 990         }\r
 991         try {\r
 992             ToscaServiceTemplate serviceTemplate = policyProvider.createPolicies(body);\r
 993             updateApiStatisticsCounter(Target.POLICY, HttpStatus.OK, HttpMethod.POST);\r
 994             return makeOkResponse(requestId, serviceTemplate);\r
 995         } catch (PfModelException | PfModelRuntimeException pfme) {\r
 996             final var msg = "POST /policies";\r
 997             updateApiStatisticsCounter(Target.POLICY, HttpStatus.resolve(pfme.getErrorResponse().getResponseCode()\r
 998                 .getStatusCode()), HttpMethod.POST);\r
 999             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
1000         }\r
1001     }\r
1002 \r
1003     /**\r
1004      * Deletes the specified version of a particular policy.\r
1005      *\r
1006      * @param policyId the ID of specified policy\r
1007      * @param policyVersion the version of specified policy\r
1008      *\r
1009      * @return the Response object containing the results of the API operation\r
1010      */\r
1011     @DeleteMapping("/policies/{policyId}/versions/{policyVersion}")\r
1012     @ApiOperation(value = "Delete a particular version of a policy",\r
1013         notes = "Rule: the version that has been deployed in PDP group(s) cannot be deleted",\r
1014         authorizations = @Authorization(value = AUTHORIZATION_TYPE), tags = {"Policy", },\r
1015         response = ToscaServiceTemplate.class,\r
1016         responseHeaders = {\r
1017             @ResponseHeader(name = VERSION_MINOR_NAME,\r
1018                 description = VERSION_MINOR_DESCRIPTION,\r
1019                 response = String.class),\r
1020             @ResponseHeader(name = VERSION_PATCH_NAME,\r
1021                 description = VERSION_PATCH_DESCRIPTION,\r
1022                 response = String.class),\r
1023             @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,\r
1024                 response = String.class),\r
1025             @ResponseHeader(name = REQUEST_ID_NAME,\r
1026                 description = REQUEST_ID_HDR_DESCRIPTION, response = UUID.class)},\r
1027         extensions = {\r
1028             @Extension(name = EXTENSION_NAME, properties = {\r
1029                 @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),\r
1030                 @ExtensionProperty(name = LAST_MOD_NAME, value = "Guilin")})})\r
1031     @ApiResponses(value = {\r
1032         @ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = AUTHENTICATION_ERROR_MESSAGE),\r
1033         @ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = AUTHORIZATION_ERROR_MESSAGE),\r
1034         @ApiResponse(code = HttpURLConnection.HTTP_NOT_FOUND, message = NOT_FOUND_MESSAGE),\r
1035         @ApiResponse(code = HttpURLConnection.HTTP_CONFLICT, message = HTTP_CONFLICT_MESSAGE),\r
1036         @ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = SERVER_ERROR_MESSAGE)})\r
1037     public ResponseEntity<ToscaServiceTemplate> deleteSpecificPolicy(\r
1038         @PathVariable("policyId") @ApiParam(value = "ID of policy", required = true) String policyId,\r
1039         @PathVariable("policyVersion") @ApiParam(value = "Version of policy", required = true) String policyVersion,\r
1040         @RequestHeader(name = REQUEST_ID_NAME, required = false)\r
1041         @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId) {\r
1042         try {\r
1043             ToscaServiceTemplate serviceTemplate =\r
1044                 policyProvider.deletePolicy(null, null, policyId, policyVersion);\r
1045             updateApiStatisticsCounter(Target.POLICY, HttpStatus.OK, HttpMethod.DELETE);\r
1046             return makeOkResponse(requestId, serviceTemplate);\r
1047         } catch (PfModelException | PfModelRuntimeException pfme) {\r
1048             var msg = String.format("DELETE /policies/%s/versions/%s", policyId, policyVersion);\r
1049             updateApiStatisticsCounter(Target.POLICY, HttpStatus.resolve(pfme.getErrorResponse().getResponseCode()\r
1050                 .getStatusCode()), HttpMethod.DELETE);\r
1051             throw new PolicyApiRuntimeException(msg, pfme.getCause(), pfme.getErrorResponse(), requestId);\r
1052         }\r
1053     }\r
1054 \r
1055     private void updateApiStatisticsCounter(Target target, HttpStatus result, HttpMethod http) {\r
1056         mgr.updateTotalApiCallCount();\r
1057         switch (target) {\r
1058             case POLICY:\r
1059                 updatePolicyStats(result, http);\r
1060                 break;\r
1061             case POLICY_TYPE:\r
1062                 updatePolicyTypeStats(result, http);\r
1063                 break;\r
1064             default:\r
1065                 mgr.updateApiCallSuccessCount();\r
1066                 break;\r
1067         }\r
1068     }\r
1069 \r
1070     private void updatePolicyStats(HttpStatus result, HttpMethod http) {\r
1071         if (result.equals(HttpStatus.OK)) {\r
1072             switch (http) {\r
1073                 case GET:\r
1074                     mgr.updateApiCallSuccessCount();\r
1075                     mgr.updateTotalPolicyGetCount();\r
1076                     mgr.updatePolicyGetSuccessCount();\r
1077                     break;\r
1078                 case POST:\r
1079                     mgr.updateApiCallSuccessCount();\r
1080                     mgr.updateTotalPolicyPostCount();\r
1081                     mgr.updatePolicyPostSuccessCount();\r
1082                     break;\r
1083                 case DELETE:\r
1084                     mgr.updateApiCallSuccessCount();\r
1085                     mgr.updateTotalPolicyDeleteCount();\r
1086                     mgr.updatePolicyDeleteSuccessCount();\r
1087                     break;\r
1088                 default:\r
1089                     mgr.updateApiCallSuccessCount();\r
1090                     break;\r
1091             }\r
1092         } else {\r
1093             switch (http) {\r
1094                 case GET:\r
1095                     mgr.updateApiCallFailureCount();\r
1096                     mgr.updateTotalPolicyGetCount();\r
1097                     mgr.updatePolicyGetFailureCount();\r
1098                     break;\r
1099                 case POST:\r
1100                     mgr.updateApiCallFailureCount();\r
1101                     mgr.updateTotalPolicyPostCount();\r
1102                     mgr.updatePolicyPostFailureCount();\r
1103                     break;\r
1104                 case DELETE:\r
1105                     mgr.updateApiCallFailureCount();\r
1106                     mgr.updateTotalPolicyDeleteCount();\r
1107                     mgr.updatePolicyDeleteFailureCount();\r
1108                     break;\r
1109                 default:\r
1110                     mgr.updateApiCallFailureCount();\r
1111                     break;\r
1112             }\r
1113         }\r
1114     }\r
1115 \r
1116     private void updatePolicyTypeStats(HttpStatus result, HttpMethod http) {\r
1117         if (result.equals(HttpStatus.OK)) {\r
1118             switch (http) {\r
1119                 case GET:\r
1120                     mgr.updateApiCallSuccessCount();\r
1121                     mgr.updateTotalPolicyTypeGetCount();\r
1122                     mgr.updatePolicyTypeGetSuccessCount();\r
1123                     break;\r
1124                 case POST:\r
1125                     mgr.updateApiCallSuccessCount();\r
1126                     mgr.updateTotalPolicyTypePostCount();\r
1127                     mgr.updatePolicyTypePostSuccessCount();\r
1128                     break;\r
1129                 case DELETE:\r
1130                     mgr.updateApiCallSuccessCount();\r
1131                     mgr.updateTotalPolicyTypeDeleteCount();\r
1132                     mgr.updatePolicyTypeDeleteSuccessCount();\r
1133                     break;\r
1134                 default:\r
1135                     mgr.updateApiCallSuccessCount();\r
1136                     break;\r
1137             }\r
1138         } else {\r
1139             switch (http) {\r
1140                 case GET:\r
1141                     mgr.updateApiCallFailureCount();\r
1142                     mgr.updateTotalPolicyTypeGetCount();\r
1143                     mgr.updatePolicyTypeGetFailureCount();\r
1144                     break;\r
1145                 case POST:\r
1146                     mgr.updateApiCallFailureCount();\r
1147                     mgr.updateTotalPolicyTypePostCount();\r
1148                     mgr.updatePolicyTypePostFailureCount();\r
1149                     break;\r
1150                 case DELETE:\r
1151                     mgr.updateApiCallFailureCount();\r
1152                     mgr.updateTotalPolicyTypeDeleteCount();\r
1153                     mgr.updatePolicyTypeDeleteFailureCount();\r
1154                     break;\r
1155                 default:\r
1156                     mgr.updateApiCallFailureCount();\r
1157                     break;\r
1158             }\r
1159         }\r
1160     }\r
1161 }