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