2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017-2019 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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.onap.policy.pdp.rest.api.controller;
23 import io.swagger.annotations.Api;
24 import io.swagger.annotations.ApiImplicitParam;
25 import io.swagger.annotations.ApiImplicitParams;
26 import io.swagger.annotations.ApiOperation;
27 import java.lang.reflect.InvocationTargetException;
28 import java.util.Collection;
29 import java.util.concurrent.atomic.AtomicLong;
30 import javax.servlet.http.HttpServletRequest;
31 import org.onap.policy.api.ConfigNameRequest;
32 import org.onap.policy.api.ConfigRequestParameters;
33 import org.onap.policy.api.DecisionRequestParameters;
34 import org.onap.policy.api.DecisionResponse;
35 import org.onap.policy.api.DeletePolicyParameters;
36 import org.onap.policy.api.DictionaryParameters;
37 import org.onap.policy.api.DictionaryResponse;
38 import org.onap.policy.api.EventRequestParameters;
39 import org.onap.policy.api.MetricsResponse;
40 import org.onap.policy.api.PolicyParameters;
41 import org.onap.policy.api.PolicyResponse;
42 import org.onap.policy.api.PushPolicyParameters;
43 import org.onap.policy.common.logging.flexlogger.FlexLogger;
44 import org.onap.policy.common.logging.flexlogger.Logger;
45 import org.onap.policy.pdp.rest.XACMLPdpServlet;
46 import org.onap.policy.pdp.rest.api.models.ConfigFirewallPolicyAPIRequest;
47 import org.onap.policy.pdp.rest.api.models.ConfigPolicyAPIRequest;
48 import org.onap.policy.pdp.rest.api.models.PolicyConfig;
49 import org.onap.policy.pdp.rest.api.services.CreateUpdateConfigPolicyService;
50 import org.onap.policy.pdp.rest.api.services.CreateUpdateDictionaryService;
51 import org.onap.policy.pdp.rest.api.services.CreateUpdateFirewallPolicyService;
52 import org.onap.policy.pdp.rest.api.services.CreateUpdatePolicyService;
53 import org.onap.policy.pdp.rest.api.services.DeletePolicyService;
54 import org.onap.policy.pdp.rest.api.services.GetConfigService;
55 import org.onap.policy.pdp.rest.api.services.GetDecisionService;
56 import org.onap.policy.pdp.rest.api.services.GetDictionaryService;
57 import org.onap.policy.pdp.rest.api.services.GetMetricsService;
58 import org.onap.policy.pdp.rest.api.services.ListConfigService;
59 import org.onap.policy.pdp.rest.api.services.ListPolicyService;
60 import org.onap.policy.pdp.rest.api.services.NotificationService;
61 import org.onap.policy.pdp.rest.api.services.NotificationService.NotificationServiceType;
62 import org.onap.policy.pdp.rest.api.services.PolicyEngineImportService;
63 import org.onap.policy.pdp.rest.api.services.PushPolicyService;
64 import org.onap.policy.pdp.rest.api.services.SendEventService;
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.DeleteMapping;
69 import org.springframework.web.bind.annotation.ExceptionHandler;
70 import org.springframework.web.bind.annotation.GetMapping;
71 import org.springframework.web.bind.annotation.PostMapping;
72 import org.springframework.web.bind.annotation.PutMapping;
73 import org.springframework.web.bind.annotation.RequestAttribute;
74 import org.springframework.web.bind.annotation.RequestBody;
75 import org.springframework.web.bind.annotation.RequestHeader;
76 import org.springframework.web.bind.annotation.RequestMapping;
77 import org.springframework.web.bind.annotation.RequestParam;
78 import org.springframework.web.bind.annotation.ResponseBody;
79 import org.springframework.web.bind.annotation.RestController;
80 import org.springframework.web.multipart.MultipartFile;
81 import springfox.documentation.annotations.ApiIgnore;
84 @Api(value = "Policy Engine Services")
86 public class PolicyEngineServices {
87 private static Logger logger = FlexLogger.getLogger(PolicyEngineServices.class.getName());
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();
108 * @param configRequestParameters the config request parameters
109 * @param clientEncoding the client encoding
110 * @param requestId the request ID
113 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
114 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
115 @ApiOperation(value = "Gets the configuration from the PolicyDecisionPoint(PDP)")
116 @PostMapping(value = "/getConfig")
118 public ResponseEntity<Collection<PolicyConfig>> getConfig(
119 @RequestBody ConfigRequestParameters configRequestParameters,
120 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
121 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
122 Collection<PolicyConfig> policyConfig = null;
123 GetConfigService getConfigService = new GetConfigService(configRequestParameters, requestId);
124 policyConfig = getConfigService.getResult();
125 HttpStatus status = getConfigService.getResponseCode();
126 configCounter.incrementAndGet();
127 return new ResponseEntity<>(policyConfig, status);
131 * Gets the config by policy name.
133 * @param configNameRequest the config name request
134 * @param clientEncoding the client encoding
135 * @param requestId the request id
136 * @return the config by policy name
138 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
139 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
140 @ApiOperation(value = "Gets the configuration from the PolicyDecisionPoint(PDP) using PolicyName")
141 @PostMapping(value = "/getConfigByPolicyName")
144 public ResponseEntity<Collection<PolicyConfig>> getConfigByPolicyName(
145 @RequestBody ConfigNameRequest configNameRequest,
146 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
147 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
148 Collection<PolicyConfig> policyConfig = null;
149 logger.info("Operation: getConfigByPolicyName - " + configNameRequest.getPolicyName());
150 ConfigRequestParameters configRequestParameters = new ConfigRequestParameters();
151 configRequestParameters.setPolicyName(configNameRequest.getPolicyName());
153 GetConfigService getConfigService = new GetConfigService(configRequestParameters, requestId);
154 policyConfig = getConfigService.getResult();
155 HttpStatus status = getConfigService.getResponseCode();
156 configNameCounter.incrementAndGet();
157 return new ResponseEntity<>(policyConfig, status);
164 * @param configRequestParameters the config request parameters
165 * @param clientEncoding the client encoding
166 * @param requestId the request ID
167 * @return the response entity
169 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
170 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
171 @ApiOperation(value = "Gets the list of configuration policies from the PDP")
172 @PostMapping(value = "/listConfig")
174 public ResponseEntity<Collection<String>> listConfig(@RequestBody ConfigRequestParameters configRequestParameters,
175 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
176 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
177 Collection<String> results = null;
178 logger.info("Operation: listConfig - " + configRequestParameters);
179 ListConfigService listConfigService = new ListConfigService(configRequestParameters, requestId);
180 results = listConfigService.getResult();
181 HttpStatus status = listConfigService.getResponseCode();
182 configCounter.incrementAndGet();
183 return new ResponseEntity<>(results, status);
189 * @param ConfigNameRequest the config request parameters
190 * @param clientEncoding the client encoding
191 * @param requestId the request ID
192 * @return the response entity
194 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
195 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
196 @ApiOperation(value = "Gets the list of policies from the PDP")
197 @PostMapping(value = "/listPolicy")
199 public ResponseEntity<Collection<String>> listPolicy(@RequestBody ConfigNameRequest configNameRequest,
200 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
201 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
202 Collection<String> results = null;
203 logger.info("Operation: listPolicy - " + configNameRequest);
204 ListPolicyService listPolicyService = new ListPolicyService(configNameRequest);
205 results = listPolicyService.getResult();
206 HttpStatus status = listPolicyService.getResponseCode();
207 configCounter.incrementAndGet();
208 return new ResponseEntity<>(results, status);
214 * @param clientEncoding the client encoding
215 * @param requestId the request ID
216 * @return the metrics
218 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
219 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
220 @ApiOperation(value = "Gets the policy metrics from the PolicyAccessPoint(PAP)")
221 @GetMapping(value = "/getMetrics")
223 public ResponseEntity<MetricsResponse> getMetrics(
224 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
225 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
226 MetricsResponse response = null;
227 logger.info("Operation: getMetrics");
229 GetMetricsService getMetricsService = new GetMetricsService(requestId);
230 response = getMetricsService.getResult();
231 HttpStatus status = getMetricsService.getResponseCode();
232 metricCounter.incrementAndGet();
233 return new ResponseEntity<>(response, status);
237 * Gets the notification.
239 * @param notificationTopic the notification topic
240 * @param clientEncoding the client encoding
241 * @param requestId the request ID
242 * @return the notification
244 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
245 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
246 @ApiOperation(value = "Registers DMaaP Topic to recieve notification from Policy Engine")
247 @PostMapping(value = "/getNotification")
249 public ResponseEntity<String> getNotification(@RequestBody String notificationTopic,
250 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
251 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
252 logger.info("Operation: getNotification for Topic: " + notificationTopic);
254 NotificationService notificationService =
255 new NotificationService(notificationTopic, requestId, NotificationServiceType.ADD);
256 String policyResponse = notificationService.getResult();
257 HttpStatus status = notificationService.getResponseCode();
258 notificationCounter.incrementAndGet();
259 return new ResponseEntity<>(policyResponse, status);
265 * @param notificationTopic the notification topic
266 * @param clientEncoding the client encoding
267 * @param requestId the request ID
268 * @return the response entity
270 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
271 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
272 @ApiOperation(value = "De-Registers DMaaP Topic to stop recieving notifications from Policy Engine")
273 @PostMapping(value = "/stopNotification")
275 public ResponseEntity<String> stopNotification(@RequestBody String notificationTopic,
276 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
277 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
278 logger.info("Operation: stopNotification for Topic: " + notificationTopic);
280 NotificationService notificationService =
281 new NotificationService(notificationTopic, requestId, NotificationServiceType.REMOVE);
282 String policyResponse = notificationService.getResult();
283 HttpStatus status = notificationService.getResponseCode();
285 notificationCounter.incrementAndGet();
286 return new ResponseEntity<>(policyResponse, status);
292 * @param notificationTopic the notification topic
293 * @param clientEncoding the client encoding
294 * @param requestId the request ID
295 * @return the response entity
297 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
298 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
300 value = "Sends Heartbeat to DMaaP Topic Registry to continue recieving notifications from Policy Engine")
301 @PostMapping(value = "/sendHeartbeat")
303 public ResponseEntity<String> sendHeartbeat(@RequestBody String notificationTopic,
304 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
305 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
306 logger.info("Operation: sendHeartbeat for topic - " + notificationTopic);
308 NotificationService notificationService =
309 new NotificationService(notificationTopic, requestId, NotificationServiceType.HB);
310 String policyResponse = notificationService.getResult();
311 HttpStatus status = notificationService.getResponseCode();
313 return new ResponseEntity<>(policyResponse, status);
319 * @param eventRequestParameters the event request parameters
320 * @param clientEncoding the client encoding
321 * @param requestId the request ID
322 * @return the response entity
324 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
325 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
326 @ApiOperation(value = "Sends the Events specified to the Policy Engine")
327 @PostMapping(value = "/sendEvent")
329 public ResponseEntity<Collection<PolicyResponse>> sendEvent(
330 @RequestBody EventRequestParameters eventRequestParameters,
331 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
332 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
333 Collection<PolicyResponse> policyResponse = null;
334 logger.info("Operation: sendEvent with EventAttributes - " + eventRequestParameters.getEventAttributes());
336 SendEventService sendEventService = new SendEventService(eventRequestParameters, requestId);
337 policyResponse = sendEventService.getResult();
338 HttpStatus status = sendEventService.getResponseCode();
339 eventCounter.incrementAndGet();
340 return new ResponseEntity<>(policyResponse, status);
346 * @param decisionRequestParameters the decision request parameters
347 * @param clientEncoding the client encoding
348 * @param requestId the request ID
349 * @return the decision
351 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
352 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
353 @ApiOperation(value = "Gets the Decision using specified decision parameters")
354 @PostMapping(value = "/getDecision")
356 public ResponseEntity<DecisionResponse> getDecision(
357 @RequestBody DecisionRequestParameters decisionRequestParameters,
358 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
359 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
360 DecisionResponse decisionResponse = null;
362 GetDecisionService getDecisionService = new GetDecisionService(decisionRequestParameters, requestId);
363 decisionResponse = getDecisionService.getResult();
364 HttpStatus status = getDecisionService.getResponseCode();
365 decisionCounter.incrementAndGet();
366 return new ResponseEntity<>(decisionResponse, status);
372 * @param pushPolicyParameters the push policy parameters
373 * @param clientEncoding the client encoding
374 * @param requestId the request ID
375 * @return the response entity
377 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
378 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
379 @ApiOperation(value = "Pushes the specified policy to the PDP Group.")
380 @PutMapping(value = "/pushPolicy")
382 public ResponseEntity<String> pushPolicy(@RequestBody PushPolicyParameters pushPolicyParameters,
383 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
384 @RequestAttribute(name = "Mechid") String mechId,
385 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
386 String response = null;
387 logger.info("Operation: pushPolicy - " + pushPolicyParameters + ", Mechid - " + mechId);
388 PushPolicyService pushPolicyService = new PushPolicyService(pushPolicyParameters, requestId);
389 response = pushPolicyService.getResult();
390 HttpStatus status = pushPolicyService.getResponseCode();
391 pushCounter.incrementAndGet();
392 return new ResponseEntity<>(response, status);
398 * @param deletePolicyParameters the delete policy parameters
399 * @param clientEncoding the client encoding
400 * @param requestId the request ID
401 * @return the response entity
403 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
404 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
405 @ApiOperation(value = "Deletes the specified policy from the PDP Group or PAP.")
406 @DeleteMapping(value = "/deletePolicy")
408 public ResponseEntity<String> deletePolicy(@RequestBody DeletePolicyParameters deletePolicyParameters,
409 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
410 @RequestAttribute(name = "Mechid") String mechId,
411 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
412 String response = null;
413 logger.info("Operation: deletePolicy - " + deletePolicyParameters + ", Mechid - " + mechId);
414 DeletePolicyService deletePolicyService = new DeletePolicyService(deletePolicyParameters, requestId);
415 response = deletePolicyService.getResult();
416 HttpStatus status = deletePolicyService.getResponseCode();
417 deleteCounter.incrementAndGet();
418 return new ResponseEntity<>(response, status);
422 * Creates the policy.
424 * @param policyParameters the policy parameters
425 * @param clientEncoding the client encoding
426 * @param requestId the request ID
427 * @return the response entity
429 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
430 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
431 @ApiOperation(value = "Creates a Policy based on given Policy Parameters.")
432 @PutMapping(value = "/createPolicy")
434 public ResponseEntity<String> createPolicy(@RequestBody PolicyParameters policyParameters,
435 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
436 @RequestAttribute(name = "Mechid") String mechId,
437 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
438 String response = null;
439 HttpStatus status = HttpStatus.UNAUTHORIZED;
440 logger.info("Operation: createPolicy for " + policyParameters.toString() + ", Mechid : " + mechId);
442 CreateUpdatePolicyService createPolicyService;
444 createPolicyService = (CreateUpdatePolicyService) XACMLPdpServlet.getCreateUpdatePolicyConstructor()
445 .newInstance(policyParameters, requestId, false);
446 response = createPolicyService.getResult();
447 status = createPolicyService.getResponseCode();
448 } catch (InstantiationException | IllegalAccessException | IllegalArgumentException
449 | InvocationTargetException e) {
450 logger.error(e.getMessage(), e);
451 response = "Problem with CreateUpdate Policy Service. ";
452 status = HttpStatus.INTERNAL_SERVER_ERROR;
454 createPolicyCounter.incrementAndGet();
455 return new ResponseEntity<>(response, status);
461 * @param policyParameters the policy parameters
462 * @param clientEncoding the client encoding
463 * @param requestId the request ID
464 * @return the response entity
466 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
467 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
468 @ApiOperation(value = "Updates a Policy based on given Policy Parameters.")
469 @PutMapping(value = "/updatePolicy")
471 public ResponseEntity<String> updatePolicy(@RequestBody PolicyParameters policyParameters,
472 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
473 @RequestAttribute(name = "Mechid") String mechId,
474 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
475 String response = null;
476 HttpStatus status = HttpStatus.UNAUTHORIZED;
477 logger.info("Operation: updatePolicy for " + policyParameters.toString() + ", MechId - " + mechId);
479 CreateUpdatePolicyService updatePolicyService;
481 updatePolicyService = (CreateUpdatePolicyService) XACMLPdpServlet.getCreateUpdatePolicyConstructor()
482 .newInstance(policyParameters, requestId, true);
483 response = updatePolicyService.getResult();
484 status = updatePolicyService.getResponseCode();
485 } catch (InstantiationException | IllegalAccessException | IllegalArgumentException
486 | InvocationTargetException e) {
487 logger.error(e.getMessage(), e);
488 response = "Problem with CreateUpdate Policy Service. ";
489 status = HttpStatus.INTERNAL_SERVER_ERROR;
491 updatePolicyCounter.incrementAndGet();
492 return new ResponseEntity<>(response, status);
496 * Creates the dictionary item.
498 * @param dictionaryParameters the dictionary parameters
499 * @param clientEncoding the client encoding
500 * @param requestId the request ID
501 * @return the response entity
503 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
504 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
505 @ApiOperation(value = "Creates a Dictionary Item for a specific dictionary based on given Parameters.")
506 @PutMapping(value = "/createDictionaryItem")
508 public ResponseEntity<String> createDictionaryItem(@RequestBody DictionaryParameters dictionaryParameters,
509 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
510 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
511 logger.info("Operation: createDictionaryItem - " + dictionaryParameters);
513 CreateUpdateDictionaryService createDictionaryService =
514 new CreateUpdateDictionaryService(dictionaryParameters, requestId, false);
515 String response = createDictionaryService.getResult();
516 HttpStatus status = createDictionaryService.getResponseCode();
517 createDictionaryCounter.incrementAndGet();
518 return new ResponseEntity<>(response, status);
522 * Update dictionary item.
524 * @param dictionaryParameters the dictionary parameters
525 * @param clientEncoding the client encoding
526 * @param requestId the request ID
527 * @return the response entity
529 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
530 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
531 @ApiOperation(value = "Updates a Dictionary Item for a specific dictionary based on given Parameters.")
532 @PutMapping(value = "/updateDictionaryItem")
534 public ResponseEntity<String> updateDictionaryItem(@RequestBody DictionaryParameters dictionaryParameters,
535 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
536 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
537 logger.info("Operation: updateDictionaryItem - " + dictionaryParameters);
539 CreateUpdateDictionaryService updateDictionaryService =
540 new CreateUpdateDictionaryService(dictionaryParameters, requestId, true);
541 String response = updateDictionaryService.getResult();
542 HttpStatus status = updateDictionaryService.getResponseCode();
543 updateDictionaryCounter.incrementAndGet();
544 return new ResponseEntity<>(response, status);
548 * Gets the dictionary items.
550 * @param dictionaryParameters the dictionary parameters
551 * @param clientEncoding the client encoding
552 * @param requestId the request ID
553 * @return the dictionary items
555 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
556 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
557 @ApiOperation(value = "Gets the dictionary items from the PAP")
558 @PostMapping(value = "/getDictionaryItems")
560 public ResponseEntity<DictionaryResponse> getDictionaryItems(@RequestBody DictionaryParameters dictionaryParameters,
561 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
562 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
563 DictionaryResponse dictionaryResponse = null;
564 logger.info("Operation: getDictionaryItems - " + dictionaryParameters);
565 GetDictionaryService getDictionaryService = new GetDictionaryService(dictionaryParameters, requestId);
566 dictionaryResponse = getDictionaryService.getResult();
567 HttpStatus status = getDictionaryService.getResponseCode();
568 getDictionaryCounter.incrementAndGet();
569 return new ResponseEntity<>(dictionaryResponse, status);
573 * Policy engine import.
575 * @param importParametersJson the import parameters json
576 * @param file the file
577 * @param clientEncoding the client encoding
578 * @param requestId the request ID
579 * @return the response entity
581 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
582 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
583 @ApiOperation(value = "Imports models and templates which represent the service used to create a policy.")
584 @PostMapping(value = "/policyEngineImport")
586 public ResponseEntity<String> policyEngineImport(@RequestParam("importParametersJson") String importParametersJson,
587 @RequestParam("file") MultipartFile file,
588 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
589 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
590 logger.info("Operation: policyEngineImport with importParametersJson: " + importParametersJson);
591 PolicyEngineImportService policyEngineImportService =
592 new PolicyEngineImportService(importParametersJson, file, requestId);
593 String response = policyEngineImportService.getResult();
594 HttpStatus status = policyEngineImportService.getResponseCode();
595 policyEngineImportCounter.incrementAndGet();
596 return new ResponseEntity<>(response, status);
600 * Creates the config.
602 * @param configPolicyAPIRequest the config policy API request
603 * @param clientEncoding the client encoding
604 * @param requestId the request id
605 * @return the response entity
607 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
608 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
609 @ApiOperation(value = "Creates a Config Policy based on given Policy Parameters.")
610 @PutMapping(value = "/createConfig")
613 public ResponseEntity<String> createConfig(@RequestBody ConfigPolicyAPIRequest configPolicyAPIRequest,
614 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
615 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
616 logger.info("Operation: createConfig");
618 CreateUpdateConfigPolicyService createPolicyService =
619 new CreateUpdateConfigPolicyService(configPolicyAPIRequest, requestId, false);
620 String response = createPolicyService.getResult();
621 HttpStatus status = createPolicyService.getResponseCode();
622 deprecatedCounter.incrementAndGet();
623 return new ResponseEntity<>(response, status);
629 * @param configPolicyAPIRequest the config policy API request
630 * @param clientEncoding the client encoding
631 * @param requestId the request id
632 * @return the response entity
634 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
635 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
636 @ApiOperation(value = "Updates a Config Policy based on given Policy Parameters.")
637 @PutMapping(value = "/updateConfig")
640 public ResponseEntity<String> updateConfig(@RequestBody ConfigPolicyAPIRequest configPolicyAPIRequest,
641 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
642 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
643 logger.info("Operation: updateConfig");
645 CreateUpdateConfigPolicyService updatePolicyService =
646 new CreateUpdateConfigPolicyService(configPolicyAPIRequest, requestId, true);
647 String response = updatePolicyService.getResult();
648 HttpStatus status = updatePolicyService.getResponseCode();
649 deprecatedCounter.incrementAndGet();
650 return new ResponseEntity<>(response, status);
654 * Creates the firewall config.
656 * @param configFirewallPolicyAPIRequest the config firewall policy API request
657 * @param clientEncoding the client encoding
658 * @param requestId the request id
659 * @return the response entity
662 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
663 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
664 @ApiOperation(value = "Creates a Config Firewall Policy")
665 @PutMapping(value = "/createFirewallConfig")
668 public ResponseEntity<String> createFirewallConfig(
669 @RequestBody ConfigFirewallPolicyAPIRequest configFirewallPolicyAPIRequest,
670 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
671 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
672 logger.info("Operation: createFirewallConfig");
674 CreateUpdateFirewallPolicyService createFirewallPolicyService =
675 new CreateUpdateFirewallPolicyService(configFirewallPolicyAPIRequest, requestId, false);
676 String response = createFirewallPolicyService.getResult();
677 HttpStatus status = createFirewallPolicyService.getResponseCode();
678 deprecatedCounter.incrementAndGet();
679 return new ResponseEntity<>(response, status);
683 * Update firewall config.
685 * @param configFirewallPolicyAPIRequest the config firewall policy API request
686 * @param clientEncoding the client encoding
687 * @param requestId the request id
688 * @return the response entity
690 @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
691 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
692 @ApiOperation(value = "Updates a Config Firewall Policy")
693 @PutMapping(value = "/updateFirewallConfig")
696 public ResponseEntity<String> updateFirewallConfig(
697 @RequestBody ConfigFirewallPolicyAPIRequest configFirewallPolicyAPIRequest,
698 @RequestHeader(value = "ClientAuth", required = false) String clientEncoding,
699 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
700 logger.info("Operation: updateFirewallConfig");
702 CreateUpdateFirewallPolicyService updateFirewallPolicyService =
703 new CreateUpdateFirewallPolicyService(configFirewallPolicyAPIRequest, requestId, true);
704 String response = updateFirewallPolicyService.getResult();
705 HttpStatus status = updateFirewallPolicyService.getResponseCode();
706 deprecatedCounter.incrementAndGet();
707 return new ResponseEntity<>(response, status);
715 @ApiOperation(value = "Gets the API Services usage Information")
717 @GetMapping(value = "/count")
718 public String getCount() {
719 return "Total Config Calls : " + configCounter + "\n" + "Total Config calls made using Policy File Name: "
720 + configNameCounter + "\n" + "Total Event Calls : " + eventCounter + "\nTotal Decision Calls: "
721 + decisionCounter + "\nTotal Push policy Calls: " + pushCounter + "\nTotal Delete Policy Calls: "
722 + deleteCounter + "\nTotal Create Policy Calls: " + createPolicyCounter
723 + "\nTotal Update Policy Calls: " + updatePolicyCounter + "\nTotal Create Dictionary Calls: "
724 + createDictionaryCounter + "\nTotal Update Dictionary Calls: " + updateDictionaryCounter
725 + "\nTotal Get Dictionary Calls: " + getDictionaryCounter + "\nTotal PolicyEngine Import Calls: "
726 + policyEngineImportCounter + "\nTotal Deprecated Policy Calls: " + deprecatedCounter
727 + "\nTotal Metrics Calls:" + metricCounter + "\nTotal Notification Calls:" + notificationCounter;
731 * Message not readable exception handler.
734 * @param exception the exception
735 * @return the response entity
737 @ExceptionHandler({HttpMessageNotReadableException.class})
738 public ResponseEntity<String> messageNotReadableExceptionHandler(HttpServletRequest req,
739 HttpMessageNotReadableException exception) {
740 logger.error("Request not readable: {}", exception);
741 StringBuilder message = new StringBuilder();
742 message.append(exception.getMessage());
743 if (exception.getCause() != null) {
744 message.append(" Reason Caused: " + exception.getCause().getMessage());
746 return new ResponseEntity<>(message.toString(), HttpStatus.BAD_REQUEST);