ECOMP-PDP-REST/src/main/java/org/openecomp/policy/pdp/rest/api/controller/PolicyEngineServices.java

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