ONAP-PDP-REST/src/main/java/org/onap/policy/pdp/rest/api/controller/PolicyEngineServices.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP-PDP-REST
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20 package org.onap.policy.pdp.rest.api.controller;
  21
  22 import io.swagger.annotations.Api;
  23 import io.swagger.annotations.ApiImplicitParam;
  24 import io.swagger.annotations.ApiImplicitParams;
  25 import io.swagger.annotations.ApiOperation;
  26
  27 import java.lang.reflect.InvocationTargetException;
  28 import java.util.Collection;
  29 import java.util.concurrent.atomic.AtomicLong;
  30
  31 import javax.servlet.http.HttpServletRequest;
  32
  33 import org.onap.policy.api.ConfigRequestParameters;
  34 import org.onap.policy.api.DecisionRequestParameters;
  35 import org.onap.policy.api.DecisionResponse;
  36 import org.onap.policy.api.DeletePolicyParameters;
  37 import org.onap.policy.api.DictionaryParameters;
  38 import org.onap.policy.api.DictionaryResponse;
  39 import org.onap.policy.api.EventRequestParameters;
  40 import org.onap.policy.api.MetricsResponse;
  41 import org.onap.policy.api.PolicyParameters;
  42 import org.onap.policy.api.PolicyResponse;
  43 import org.onap.policy.api.PushPolicyParameters;
  44 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  45 import org.onap.policy.common.logging.flexlogger.Logger;
  46 import org.onap.policy.pdp.rest.XACMLPdpServlet;
  47 import org.onap.policy.pdp.rest.api.models.ConfigFirewallPolicyAPIRequest;
  48 import org.onap.policy.pdp.rest.api.models.ConfigNameRequest;
  49 import org.onap.policy.pdp.rest.api.models.ConfigPolicyAPIRequest;
  50 import org.onap.policy.pdp.rest.api.models.PolicyConfig;
  51 import org.onap.policy.pdp.rest.api.services.CreateUpdateConfigPolicyService;
  52 import org.onap.policy.pdp.rest.api.services.CreateUpdateDictionaryService;
  53 import org.onap.policy.pdp.rest.api.services.CreateUpdateFirewallPolicyService;
  54 import org.onap.policy.pdp.rest.api.services.CreateUpdatePolicyService;
  55 import org.onap.policy.pdp.rest.api.services.DeletePolicyService;
  56 import org.onap.policy.pdp.rest.api.services.GetConfigService;
  57 import org.onap.policy.pdp.rest.api.services.GetDecisionService;
  58 import org.onap.policy.pdp.rest.api.services.GetDictionaryService;
  59 import org.onap.policy.pdp.rest.api.services.GetMetricsService;
  60 import org.onap.policy.pdp.rest.api.services.ListConfigService;
  61 import org.onap.policy.pdp.rest.api.services.NotificationService;
  62 import org.onap.policy.pdp.rest.api.services.NotificationService.NotificationServiceType;
  63 import org.onap.policy.pdp.rest.api.services.PolicyEngineImportService;
  64 import org.onap.policy.pdp.rest.api.services.PushPolicyService;
  65 import org.onap.policy.pdp.rest.api.services.SendEventService;
  66 import org.onap.policy.pdp.rest.config.PDPApiAuth;
  67 import org.springframework.http.HttpStatus;
  68 import org.springframework.http.ResponseEntity;
  69 import org.springframework.http.converter.HttpMessageNotReadableException;
  70 import org.springframework.web.bind.annotation.ExceptionHandler;
  71 import org.springframework.web.bind.annotation.RequestBody;
  72 import org.springframework.web.bind.annotation.RequestHeader;
  73 import org.springframework.web.bind.annotation.RequestMapping;
  74 import org.springframework.web.bind.annotation.RequestMethod;
  75 import org.springframework.web.bind.annotation.RequestParam;
  76 import org.springframework.web.bind.annotation.ResponseBody;
  77 import org.springframework.web.bind.annotation.RestController;
  78 import org.springframework.web.multipart.MultipartFile;
  79
  80 import springfox.documentation.annotations.ApiIgnore;
  81
  82 @RestController
  83 @Api(value = "Policy Engine Services")
  84 @RequestMapping("/")
  85 public class PolicyEngineServices {
  86         private static Logger logger = FlexLogger.getLogger(PolicyEngineServices.class.getName());
  87         private static final String NOTIFICATIONPERM = "notification";
  88
  89         private final AtomicLong configCounter = new AtomicLong();
  90         private final AtomicLong configNameCounter = new AtomicLong();
  91         private final AtomicLong eventCounter = new AtomicLong();
  92         private final AtomicLong decisionCounter = new AtomicLong();
  93         private final AtomicLong pushCounter = new AtomicLong();
  94         private final AtomicLong deleteCounter = new AtomicLong();
  95         private final AtomicLong createPolicyCounter = new AtomicLong();
  96         private final AtomicLong updatePolicyCounter = new AtomicLong();
  97         private final AtomicLong createDictionaryCounter = new AtomicLong();
  98         private final AtomicLong updateDictionaryCounter = new AtomicLong();
  99         private final AtomicLong getDictionaryCounter = new AtomicLong();
 100         private final AtomicLong policyEngineImportCounter = new AtomicLong();
 101         private final AtomicLong deprecatedCounter = new AtomicLong();
 102         private final AtomicLong metricCounter = new AtomicLong();
 103         private final AtomicLong notificationCounter = new AtomicLong();
 104
 105         @ApiImplicitParams({
 106                         @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 107                         @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 108         @ApiOperation(value = "Gets the configuration from the PolicyDecisionPoint(PDP)")
 109         @RequestMapping(value = "/getConfig", method = RequestMethod.POST)
 110         @ResponseBody
 111         public ResponseEntity<Collection<PolicyConfig>> getConfig(
 112                         @RequestBody ConfigRequestParameters configRequestParameters,
 113                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 114                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 115                 Collection<PolicyConfig> policyConfig = null;
 116                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 117                 // Check Permissions.
 118                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "getConfig")) {
 119                         GetConfigService getConfigService = new GetConfigService(
 120                                         configRequestParameters, requestID);
 121                         policyConfig = getConfigService.getResult();
 122                         status = getConfigService.getResponseCode();
 123                 }
 124                 configCounter.incrementAndGet();
 125                 return new ResponseEntity<>(policyConfig, status);
 126         }
 127
 128         @ApiImplicitParams({
 129                         @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 130                         @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 131         @ApiOperation(value = "Gets the configuration from the PolicyDecisionPoint(PDP) using PolicyName")
 132         @RequestMapping(value = "/getConfigByPolicyName", method = RequestMethod.POST)
 133         @ResponseBody
 134         @Deprecated
 135         public ResponseEntity<Collection<PolicyConfig>> getConfigByPolicyName(
 136                         @RequestBody ConfigNameRequest configNameRequest,
 137                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 138                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 139                 Collection<PolicyConfig> policyConfig = null;
 140                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 141                 // Check Permissions.
 142                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,"getConfigByPolicyName")) {
 143                         ConfigRequestParameters configRequestParameters = new ConfigRequestParameters();
 144                         configRequestParameters.setPolicyName(configNameRequest
 145                                         .getPolicyName());
 146                         GetConfigService getConfigService = new GetConfigService(
 147                                         configRequestParameters, requestID);
 148                         policyConfig = getConfigService.getResult();
 149                         status = getConfigService.getResponseCode();
 150                 }
 151                 configNameCounter.incrementAndGet();
 152                 return new ResponseEntity<>(policyConfig, status);
 153         }
 154
 155         @ApiImplicitParams({
 156                         @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 157                         @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 158         @ApiOperation(value = "Gets the list of configuration policies from the PDP")
 159         @RequestMapping(value = "/listConfig", method = RequestMethod.POST)
 160         @ResponseBody
 161         public ResponseEntity<Collection<String>> listConfig(
 162                         @RequestBody ConfigRequestParameters configRequestParameters,
 163                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 164                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 165                 Collection<String> results = null;
 166                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 167                 // Check Permissions.
 168                 if (PDPApiAuth
 169                                 .checkPermissions(clientEncoding, requestID, "listConfig")) {
 170                         ListConfigService listConfigService = new ListConfigService(
 171                                         configRequestParameters, requestID);
 172                         results = listConfigService.getResult();
 173                         status = listConfigService.getResponseCode();
 174                 }
 175                 configCounter.incrementAndGet();
 176                 return new ResponseEntity<>(results, status);
 177         }
 178
 179         @ApiImplicitParams({
 180                 @ApiImplicitParam(name ="Authorization", required = true, paramType = "Header"),
 181                 @ApiImplicitParam(name ="Environment", required = true, paramType = "Header")
 182         })
 183         @ApiOperation(value= "Gets the policy metrics from the PolicyAccessPoint(PAP)")
 184         @RequestMapping(value="/getMetrics", method=RequestMethod.GET)
 185         @ResponseBody
 186         public ResponseEntity<MetricsResponse> getMetrics(
 187                         @RequestHeader(value="ClientAuth", required=true)String clientEncoding,
 188                         @RequestHeader(value="X-ECOMP-RequestID", required=false)String requestID) {
 189                 MetricsResponse response = null;
 190                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 191                 // Check Permissions.
 192                 if(PDPApiAuth.checkPermissions(clientEncoding, requestID, "getMetrics")){
 193                         GetMetricsService getMetricsService = new GetMetricsService(requestID);
 194                         response = getMetricsService.getResult();
 195                         status = getMetricsService.getResponseCode();
 196                 }
 197                 metricCounter.incrementAndGet();
 198                 return new ResponseEntity<>(response, status);
 199         }
 200
 201         @ApiImplicitParams({
 202                 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 203                 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 204         @ApiOperation(value = "Registers DMaaP Topic to recieve notification from Policy Engine")
 205         @RequestMapping(value = "/getNotification", method = RequestMethod.POST)
 206         @ResponseBody
 207         public ResponseEntity<String> getNotification(
 208                         @RequestBody String notificationTopic,
 209                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 210                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 211                 String policyResponse = "Error Unauthorized to use Notification Service.";
 212                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 213                 // Check Permissions.
 214                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID, NOTIFICATIONPERM)) {
 215                         NotificationService notificationService = new NotificationService(notificationTopic, requestID, NotificationServiceType.ADD);
 216                         policyResponse = notificationService.getResult();
 217                         status = notificationService.getResponseCode();
 218                 }
 219                 notificationCounter.incrementAndGet();
 220                 return new ResponseEntity<>(policyResponse, status);
 221         }
 222
 223         @ApiImplicitParams({
 224                 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 225                 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 226         @ApiOperation(value = "De-Registers DMaaP Topic to stop recieving notifications from Policy Engine")
 227         @RequestMapping(value = "/stopNotification", method = RequestMethod.POST)
 228         @ResponseBody
 229         public ResponseEntity<String> stopNotification(
 230                         @RequestBody String notificationTopic,
 231                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 232                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 233                 String policyResponse = "Error Unauthorized to use Notification Service.";
 234                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 235                 // Check Permissions.
 236                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID, NOTIFICATIONPERM)) {
 237                         NotificationService notificationService = new NotificationService(notificationTopic, requestID, NotificationServiceType.REMOVE);
 238                         policyResponse = notificationService.getResult();
 239                         status = notificationService.getResponseCode();
 240                 }
 241                 notificationCounter.incrementAndGet();
 242                 return new ResponseEntity<>(policyResponse, status);
 243         }
 244
 245         @ApiImplicitParams({
 246                 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 247                 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 248         @ApiOperation(value = "Sends Heartbeat to DMaaP Topic Registry to continue recieving notifications from Policy Engine")
 249         @RequestMapping(value = "/sendHeartbeat", method = RequestMethod.POST)
 250         @ResponseBody
 251         public ResponseEntity<String> sendHeartbeat(
 252                         @RequestBody String notificationTopic,
 253                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 254                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 255                 String policyResponse = "Error Unauthorized to use Heartbeat Service.";
 256                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 257                 // Check Permissions.
 258                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID, NOTIFICATIONPERM)) {
 259                         NotificationService notificationService = new NotificationService(notificationTopic, requestID, NotificationServiceType.HB);
 260                         policyResponse = notificationService.getResult();
 261                         status = notificationService.getResponseCode();
 262                 }
 263                 return new ResponseEntity<>(policyResponse, status);
 264         }
 265
 266         @ApiImplicitParams({
 267                         @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 268                         @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 269         @ApiOperation(value = "Sends the Events specified to the Policy Engine")
 270         @RequestMapping(value = "/sendEvent", method = RequestMethod.POST)
 271         @ResponseBody
 272         public ResponseEntity<Collection<PolicyResponse>> sendEvent(
 273                         @RequestBody EventRequestParameters eventRequestParameters,
 274                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 275                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 276                 Collection<PolicyResponse> policyResponse = null;
 277                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 278                 // Check Permissions.
 279                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "sendEvent")) {
 280                         SendEventService sendEventService = new SendEventService(
 281                                         eventRequestParameters, requestID);
 282                         policyResponse = sendEventService.getResult();
 283                         status = sendEventService.getResponseCode();
 284                 }
 285                 eventCounter.incrementAndGet();
 286                 return new ResponseEntity<>(policyResponse,
 287                                 status);
 288         }
 289
 290         @ApiImplicitParams({
 291                         @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 292                         @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 293         @ApiOperation(value = "Gets the Decision using specified decision parameters")
 294         @RequestMapping(value = "/getDecision", method = RequestMethod.POST)
 295         @ResponseBody
 296         public ResponseEntity<DecisionResponse> getDecision(
 297                         @RequestBody DecisionRequestParameters decisionRequestParameters,
 298                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 299                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 300                 DecisionResponse decisionResponse = null;
 301                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 302                 // Check Permissions.
 303                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
 304                                 "getDecision")) {
 305                         GetDecisionService getDecisionService = new GetDecisionService(
 306                                         decisionRequestParameters, requestID);
 307                         decisionResponse = getDecisionService.getResult();
 308                         status = getDecisionService.getResponseCode();
 309                 }
 310                 decisionCounter.incrementAndGet();
 311                 return new ResponseEntity<>(decisionResponse, status);
 312         }
 313
 314         @ApiImplicitParams({
 315                         @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 316                         @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 317         @ApiOperation(value = "Pushes the specified policy to the PDP Group.")
 318         @RequestMapping(value = "/pushPolicy", method = RequestMethod.PUT)
 319         @ResponseBody
 320         public ResponseEntity<String> pushPolicy(
 321                         @RequestBody PushPolicyParameters pushPolicyParameters,
 322                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 323                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 324                 String response = null;
 325                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 326                 // Check Permissions.
 327                 if (PDPApiAuth
 328                                 .checkPermissions(clientEncoding, requestID, "pushPolicy")) {
 329                         PushPolicyService pushPolicyService = new PushPolicyService(
 330                                         pushPolicyParameters, requestID);
 331                         response = pushPolicyService.getResult();
 332                         status = pushPolicyService.getResponseCode();
 333                 }
 334                 pushCounter.incrementAndGet();
 335                 return new ResponseEntity<>(response, status);
 336         }
 337
 338         @ApiImplicitParams({
 339                         @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 340                         @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 341         @ApiOperation(value = "Deletes the specified policy from the PDP Group or PAP.")
 342         @RequestMapping(value = "/deletePolicy", method = RequestMethod.DELETE)
 343         @ResponseBody
 344         public ResponseEntity<String> deletePolicy(
 345                         @RequestBody DeletePolicyParameters deletePolicyParameters,
 346                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 347                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 348                 String response = null;
 349                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 350                 // Check Permissions.
 351                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
 352                                 "deletePolicy")) {
 353                         DeletePolicyService deletePolicyService = new DeletePolicyService(
 354                                         deletePolicyParameters, requestID);
 355                         response = deletePolicyService.getResult();
 356                         status = deletePolicyService.getResponseCode();
 357                 }
 358                 deleteCounter.incrementAndGet();
 359                 return new ResponseEntity<>(response, status);
 360         }
 361
 362         @ApiImplicitParams({
 363                         @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 364                         @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 365         @ApiOperation(value = "Creates a Policy based on given Policy Parameters.")
 366         @RequestMapping(value = "/createPolicy", method = RequestMethod.PUT)
 367         @ResponseBody
 368         public ResponseEntity<String> createPolicy(
 369                         @RequestBody PolicyParameters policyParameters,
 370                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 371                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 372                 String response = null;
 373                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 374                 // Check Permissions.
 375                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
 376                                 "createPolicy")) {
 377                         CreateUpdatePolicyService createPolicyService;
 378                         try {
 379                                 createPolicyService = (CreateUpdatePolicyService) XACMLPdpServlet.getCreateUpdatePolicyConstructor().newInstance(
 380                                                 policyParameters, requestID, false);
 381                                 response = createPolicyService.getResult();
 382                                 status = createPolicyService.getResponseCode();
 383                         } catch (InstantiationException | IllegalAccessException
 384                                         | IllegalArgumentException | InvocationTargetException e) {
 385                                 logger.error(e.getMessage(), e);
 386                                 response = "Problem with CreateUpdate Policy Service. ";
 387                                 status = HttpStatus.INTERNAL_SERVER_ERROR;
 388                         }
 389                 }
 390                 createPolicyCounter.incrementAndGet();
 391                 return new ResponseEntity<>(response, status);
 392         }
 393
 394         @ApiImplicitParams({
 395                         @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 396                         @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 397         @ApiOperation(value = "Updates a Policy based on given Policy Parameters.")
 398         @RequestMapping(value = "/updatePolicy", method = RequestMethod.PUT)
 399         @ResponseBody
 400         public ResponseEntity<String> updatePolicy(
 401                         @RequestBody PolicyParameters policyParameters,
 402                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 403                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 404                 String response = null;
 405                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 406                 // Check Permissions.
 407                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
 408                                 "updatePolicy")) {
 409                         CreateUpdatePolicyService updatePolicyService;
 410                         try {
 411                                 updatePolicyService = (CreateUpdatePolicyService) XACMLPdpServlet.getCreateUpdatePolicyConstructor().newInstance(
 412                                                 policyParameters, requestID, true);
 413                                 response = updatePolicyService.getResult();
 414                                 status = updatePolicyService.getResponseCode();
 415                         } catch (InstantiationException | IllegalAccessException
 416                                         | IllegalArgumentException | InvocationTargetException e) {
 417                                 logger.error(e.getMessage(), e);
 418                                 response = "Problem with CreateUpdate Policy Service. ";
 419                                 status = HttpStatus.INTERNAL_SERVER_ERROR;
 420                         }
 421                 }
 422                 updatePolicyCounter.incrementAndGet();
 423                 return new ResponseEntity<>(response, status);
 424         }
 425
 426         @ApiImplicitParams({
 427                         @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 428                         @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 429         @ApiOperation(value = "Creates a Dictionary Item for a specific dictionary based on given Parameters.")
 430         @RequestMapping(value = "/createDictionaryItem", method = RequestMethod.PUT)
 431         @ResponseBody
 432         public ResponseEntity<String> createDictionaryItem(
 433                         @RequestBody DictionaryParameters dictionaryParameters,
 434                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 435                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 436                 String response = null;
 437                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 438                 // Check Permissions.
 439                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
 440                                 "createDictionary")) {
 441                         CreateUpdateDictionaryService createDictionaryService = new CreateUpdateDictionaryService(
 442                                         dictionaryParameters, requestID, false);
 443                         response = createDictionaryService.getResult();
 444                         status = createDictionaryService.getResponseCode();
 445                 }
 446                 createDictionaryCounter.incrementAndGet();
 447                 return new ResponseEntity<>(response, status);
 448         }
 449
 450         @ApiImplicitParams({
 451                         @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 452                         @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 453         @ApiOperation(value = "Updates a Dictionary Item for a specific dictionary based on given Parameters.")
 454         @RequestMapping(value = "/updateDictionaryItem", method = RequestMethod.PUT)
 455         @ResponseBody
 456         public ResponseEntity<String> updateDictionaryItem(
 457                         @RequestBody DictionaryParameters dictionaryParameters,
 458                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 459                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 460                 String response = null;
 461                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 462                 // Check Permissions.
 463                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
 464                                 "updateDictionary")) {
 465                         CreateUpdateDictionaryService updateDictionaryService = new CreateUpdateDictionaryService(
 466                                         dictionaryParameters, requestID, true);
 467                         response = updateDictionaryService.getResult();
 468                         status = updateDictionaryService.getResponseCode();
 469                 }
 470                 updateDictionaryCounter.incrementAndGet();
 471                 return new ResponseEntity<>(response, status);
 472         }
 473
 474         @ApiImplicitParams({
 475                         @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 476                         @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 477         @ApiOperation(value = "Gets the dictionary items from the PAP")
 478         @RequestMapping(value = "/getDictionaryItems", method = RequestMethod.POST)
 479         @ResponseBody
 480         public ResponseEntity<DictionaryResponse> getDictionaryItems(
 481                         @RequestBody DictionaryParameters dictionaryParameters,
 482                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 483                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 484                 DictionaryResponse dictionaryResponse = null;
 485                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 486                 // Check Permissions.
 487                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
 488                                 "getDictionary")) {
 489                         GetDictionaryService getDictionaryService = new GetDictionaryService(
 490                                         dictionaryParameters, requestID);
 491                         dictionaryResponse = getDictionaryService.getResult();
 492                         status = getDictionaryService.getResponseCode();
 493                 }
 494                 getDictionaryCounter.incrementAndGet();
 495                 return new ResponseEntity<>(dictionaryResponse,
 496                                 status);
 497         }
 498
 499         @ApiImplicitParams({
 500                         @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 501                         @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 502         @ApiOperation(value = "Imports Policy based on the parameters which represent the service used to create a policy Service.")
 503         @RequestMapping(value = "/policyEngineImport", method = RequestMethod.POST)
 504         @ResponseBody
 505         public ResponseEntity<String> policyEngineImport(
 506                         @RequestParam("importParametersJson") String importParametersJson,
 507                         @RequestParam("file") MultipartFile file,
 508                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 509                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 510                 String response = null;
 511                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 512                 // Check Permissions.
 513                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
 514                                 "policyEngineImport")) {
 515                         PolicyEngineImportService policyEngineImportService = new PolicyEngineImportService(
 516                                         importParametersJson, file, requestID);
 517                         response = policyEngineImportService.getResult();
 518                         status = policyEngineImportService.getResponseCode();
 519                 }
 520                 policyEngineImportCounter.incrementAndGet();
 521                 return new ResponseEntity<>(response, status);
 522         }
 523
 524         @ApiImplicitParams({
 525                         @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 526                         @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 527         @ApiOperation(value = "Creates a Config Policy based on given Policy Parameters.")
 528         @RequestMapping(value = "/createConfig", method = RequestMethod.PUT)
 529         @ResponseBody
 530         @Deprecated
 531         public ResponseEntity<String> createConfig(
 532                         @RequestBody ConfigPolicyAPIRequest configPolicyAPIRequest,
 533                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 534                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 535                 String response = null;
 536                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 537                 // Check Permissions.
 538                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
 539                                 "createPolicy")) {
 540                         CreateUpdateConfigPolicyService createPolicyService = new CreateUpdateConfigPolicyService(
 541                                         configPolicyAPIRequest, requestID, false);
 542                         response = createPolicyService.getResult();
 543                         status = createPolicyService.getResponseCode();
 544                 }
 545                 deprecatedCounter.incrementAndGet();
 546                 return new ResponseEntity<>(response, status);
 547         }
 548
 549         @ApiImplicitParams({
 550                         @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 551                         @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 552         @ApiOperation(value = "Updates a Config Policy based on given Policy Parameters.")
 553         @RequestMapping(value = "/updateConfig", method = RequestMethod.PUT)
 554         @ResponseBody
 555         @Deprecated
 556         public ResponseEntity<String> updateConfig(
 557                         @RequestBody ConfigPolicyAPIRequest configPolicyAPIRequest,
 558                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 559                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 560                 String response = null;
 561                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 562                 // Check Permissions.
 563                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
 564                                 "updatePolicy")) {
 565                         CreateUpdateConfigPolicyService updatePolicyService = new CreateUpdateConfigPolicyService(
 566                                         configPolicyAPIRequest, requestID, true);
 567                         response = updatePolicyService.getResult();
 568                         status = updatePolicyService.getResponseCode();
 569                 }
 570                 deprecatedCounter.incrementAndGet();
 571                 return new ResponseEntity<>(response, status);
 572         }
 573
 574         @ApiImplicitParams({
 575                         @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 576                         @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 577         @ApiOperation(value = "Creates a Config Firewall Policy")
 578         @RequestMapping(value = "/createFirewallConfig", method = RequestMethod.PUT)
 579         @ResponseBody
 580         @Deprecated
 581         public ResponseEntity<String> createFirewallConfig(
 582                         @RequestBody ConfigFirewallPolicyAPIRequest configFirewallPolicyAPIRequest,
 583                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 584                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 585                 String response = null;
 586                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 587                 // Check Permissions.
 588                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
 589                                 "createPolicy")) {
 590                         CreateUpdateFirewallPolicyService createFirewallPolicyService = new CreateUpdateFirewallPolicyService(
 591                                         configFirewallPolicyAPIRequest, requestID, false);
 592                         response = createFirewallPolicyService.getResult();
 593                         status = createFirewallPolicyService.getResponseCode();
 594                 }
 595                 deprecatedCounter.incrementAndGet();
 596                 return new ResponseEntity<>(response, status);
 597         }
 598
 599         @ApiImplicitParams({
 600                         @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 601                         @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
 602         @ApiOperation(value = "Updates a Config Firewall Policy")
 603         @RequestMapping(value = "/updateFirewallConfig", method = RequestMethod.PUT)
 604         @ResponseBody
 605         @Deprecated
 606         public ResponseEntity<String> updateFirewallConfig(
 607                         @RequestBody ConfigFirewallPolicyAPIRequest configFirewallPolicyAPIRequest,
 608                         @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 609                         @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 610                 String response = null;
 611                 HttpStatus status = HttpStatus.UNAUTHORIZED;
 612                 // Check Permissions.
 613                 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
 614                                 "updatePolicy")) {
 615                         CreateUpdateFirewallPolicyService updateFirewallPolicyService = new CreateUpdateFirewallPolicyService(
 616                                         configFirewallPolicyAPIRequest, requestID, true);
 617                         response = updateFirewallPolicyService.getResult();
 618                         status = updateFirewallPolicyService.getResponseCode();
 619                 }
 620                 deprecatedCounter.incrementAndGet();
 621                 return new ResponseEntity<>(response, status);
 622         }
 623
 624         @ApiOperation(value = "Gets the API Services usage Information")
 625         @ApiIgnore
 626         @RequestMapping(value = "/count", method = RequestMethod.GET)
 627         public String getCount() {
 628                 return "Total Config Calls : " + configCounter + "\n"
 629                                 + "Total Config calls made using Policy File Name: "
 630                                 + configNameCounter + "\n" + "Total Event Calls : "
 631                                 + eventCounter + "\nTotal Decision Calls: " + decisionCounter
 632                                 + "\nTotal Push policy Calls: " + pushCounter
 633                                 + "\nTotal Delete Policy Calls: " + deleteCounter
 634                                 + "\nTotal Create Policy Calls: " + createPolicyCounter
 635                                 + "\nTotal Update Policy Calls: " + updatePolicyCounter
 636                                 + "\nTotal Create Dictionary Calls: " + createDictionaryCounter
 637                                 + "\nTotal Update Dictionary Calls: " + updateDictionaryCounter
 638                                 + "\nTotal Get Dictionary Calls: " + getDictionaryCounter
 639                                 + "\nTotal PolicyEngine Import Calls: "
 640                                 + policyEngineImportCounter
 641                                 + "\nTotal Deprecated Policy Calls: " + deprecatedCounter
 642                                 + "\nTotal Metrics Calls:" + metricCounter
 643                                 + "\nTotal Notification Calls:" + notificationCounter;
 644         }
 645
 646         @ExceptionHandler({ HttpMessageNotReadableException.class })
 647         public ResponseEntity<String> messageNotReadableExceptionHandler(
 648                         HttpServletRequest req, HttpMessageNotReadableException exception) {
 649                 logger.error("Request not readable: {}", exception);
 650                 StringBuilder message = new StringBuilder();
 651                 message.append(exception.getMessage());
 652                 if (exception.getCause() != null) {
 653                         message.append(" Reason Caused: "
 654                                         + exception.getCause().getMessage());
 655                 }
 656                 return new ResponseEntity<>(message.toString(), HttpStatus.BAD_REQUEST);
 657         }
 658 }