POLICY-SDK-APP/src/main/java/org/onap/policy/admin/PolicyRestController.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP Policy Engine
   4  * ================================================================================
   5  * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20 package org.onap.policy.admin;
  21
  22 import java.io.ByteArrayInputStream;
  23 import java.io.File;
  24 import java.io.IOException;
  25 import java.io.InputStream;
  26 import java.io.OutputStream;
  27 import java.io.PrintWriter;
  28 import java.net.HttpURLConnection;
  29 import java.net.URL;
  30 import java.nio.charset.StandardCharsets;
  31 import java.util.ArrayList;
  32 import java.util.Base64;
  33 import java.util.List;
  34
  35 import javax.servlet.http.HttpServletRequest;
  36 import javax.servlet.http.HttpServletResponse;
  37
  38 import org.apache.commons.fileupload.FileItem;
  39 import org.apache.commons.fileupload.disk.DiskFileItemFactory;
  40 import org.apache.commons.fileupload.servlet.ServletFileUpload;
  41 import org.apache.commons.io.IOUtils;
  42 import org.json.JSONObject;
  43 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  44 import org.onap.policy.common.logging.flexlogger.Logger;
  45 import org.onap.policy.controller.CreateClosedLoopFaultController;
  46 import org.onap.policy.controller.CreateDcaeMicroServiceController;
  47 import org.onap.policy.controller.CreateFirewallController;
  48 import org.onap.policy.controller.CreateOptimizationController;
  49 import org.onap.policy.controller.PolicyController;
  50 import org.onap.policy.rest.XACMLRestProperties;
  51 import org.onap.policy.rest.adapter.PolicyRestAdapter;
  52 import org.onap.policy.rest.dao.CommonClassDao;
  53 import org.onap.policy.rest.jpa.PolicyVersion;
  54 import org.onap.policy.utils.PolicyUtils;
  55 import org.onap.policy.xacml.api.XACMLErrorConstants;
  56 import org.onap.portalsdk.core.controller.RestrictedBaseController;
  57 import org.onap.portalsdk.core.web.support.UserUtils;
  58 import org.springframework.beans.factory.annotation.Autowired;
  59 import org.springframework.http.HttpEntity;
  60 import org.springframework.http.HttpHeaders;
  61 import org.springframework.http.HttpMethod;
  62 import org.springframework.http.HttpStatus;
  63 import org.springframework.http.ResponseEntity;
  64 import org.springframework.web.bind.annotation.RequestMapping;
  65 import org.springframework.web.bind.annotation.RequestMethod;
  66 import org.springframework.web.bind.annotation.RestController;
  67 import org.springframework.web.client.HttpClientErrorException;
  68 import org.springframework.web.client.RestTemplate;
  69 import org.springframework.web.servlet.ModelAndView;
  70 import org.onap.policy.utils.CryptoUtils;
  71 import com.att.research.xacml.util.XACMLProperties;
  72 import com.fasterxml.jackson.databind.DeserializationFeature;
  73 import com.fasterxml.jackson.databind.JsonNode;
  74 import com.fasterxml.jackson.databind.ObjectMapper;
  75 import com.fasterxml.jackson.databind.SerializationFeature;
  76
  77 @RestController
  78 @RequestMapping("/")
  79 public class PolicyRestController extends RestrictedBaseController{
  80
  81         private static final Logger policyLogger = FlexLogger.getLogger(PolicyRestController.class);
  82
  83         private static final String model = "model";
  84         private static final String importDictionary = "import_dictionary";
  85
  86         private static CommonClassDao commonClassDao;
  87
  88         public PolicyRestController(){
  89                 //default constructor
  90         }
  91
  92         @Autowired
  93         private PolicyRestController(CommonClassDao commonClassDao){
  94                 PolicyRestController.commonClassDao = commonClassDao;
  95         }
  96
  97         public static CommonClassDao getCommonClassDao() {
  98                 return commonClassDao;
  99         }
 100
 101         public static void setCommonClassDao(CommonClassDao commonClassDao) {
 102                 PolicyRestController.commonClassDao = commonClassDao;
 103         }
 104
 105
 106
 107         @RequestMapping(value={"/policycreation/save_policy"}, method={RequestMethod.POST})
 108         public void policyCreationController(HttpServletRequest request, HttpServletResponse response) {
 109                 String userId = UserUtils.getUserSession(request).getOrgUserId();
 110                 ObjectMapper mapper = new ObjectMapper();
 111                 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 112                 try{
 113                         JsonNode root = mapper.readTree(request.getReader());
 114
 115                         policyLogger.info("****************************************Logging UserID while Create/Update Policy**************************************************");
 116                         policyLogger.info("UserId:  " + userId + "Policy Data Object:  "+ root.get(PolicyController.getPolicydata()).get("policy").toString());
 117                         policyLogger.info("***********************************************************************************************************************************");
 118
 119                         PolicyRestAdapter policyData = mapper.readValue(root.get(PolicyController.getPolicydata()).get("policy").toString(), PolicyRestAdapter.class);
 120
 121                         if("file".equals(root.get(PolicyController.getPolicydata()).get(model).get("type").toString().replace("\"", ""))){
 122                                 policyData.setEditPolicy(true);
 123                         }
 124                         if(root.get(PolicyController.getPolicydata()).get(model).get("path").size() != 0){
 125                                 String dirName = "";
 126                                 for(int i = 0; i < root.get(PolicyController.getPolicydata()).get(model).get("path").size(); i++){
 127                                         dirName = dirName.replace("\"", "") + root.get(PolicyController.getPolicydata()).get(model).get("path").get(i).toString().replace("\"", "") + File.separator;
 128                                 }
 129                                 if(policyData.isEditPolicy()){
 130                                         policyData.setDomainDir(dirName.substring(0, dirName.lastIndexOf(File.separator)));
 131                                 }else{
 132                                         policyData.setDomainDir(dirName + root.get(PolicyController.getPolicydata()).get(model).get("name").toString().replace("\"", ""));
 133                                 }
 134                         }else{
 135                                 String domain = root.get(PolicyController.getPolicydata()).get(model).get("name").toString();
 136                                 if(domain.contains("/")){
 137                                         domain = domain.substring(0, domain.lastIndexOf('/')).replace("/", File.separator);
 138                                 }
 139                                 domain = domain.replace("\"", "");
 140                                 policyData.setDomainDir(domain);
 141                         }
 142
 143                         if(policyData.getConfigPolicyType() != null){
 144                                 if("ClosedLoop_Fault".equalsIgnoreCase(policyData.getConfigPolicyType())){
 145                                         policyData = new CreateClosedLoopFaultController().setDataToPolicyRestAdapter(policyData, root);
 146                                 }else if("Firewall Config".equalsIgnoreCase(policyData.getConfigPolicyType())){
 147                                         policyData = new CreateFirewallController().setDataToPolicyRestAdapter(policyData);
 148                                 }else if("Micro Service".equalsIgnoreCase(policyData.getConfigPolicyType())){
 149                                         policyData = new CreateDcaeMicroServiceController().setDataToPolicyRestAdapter(policyData, root);
 150                                 }else if("Optimization".equalsIgnoreCase(policyData.getConfigPolicyType())){
 151                                         policyData = new CreateOptimizationController().setDataToPolicyRestAdapter(policyData, root);
 152                                 }
 153                         }
 154
 155                         policyData.setUserId(userId);
 156
 157                         String result;
 158                         String body = PolicyUtils.objectToJsonString(policyData);
 159                         String uri = request.getRequestURI();
 160                         ResponseEntity<?> responseEntity = sendToPAP(body, uri, HttpMethod.POST);
 161                         if(responseEntity != null && responseEntity.getBody().equals(HttpServletResponse.SC_CONFLICT)){
 162                                 result = "PolicyExists";
 163                         }else if(responseEntity != null){
 164                                 result =  responseEntity.getBody().toString();
 165                                 String policyName = responseEntity.getHeaders().get("policyName").get(0);
 166                                 if(policyData.isEditPolicy() && "success".equalsIgnoreCase(result)){
 167                                         PolicyNotificationMail email = new PolicyNotificationMail();
 168                                         String mode = "EditPolicy";
 169                                         String watchPolicyName = policyName.replace(".xml", "");
 170                                         String version = watchPolicyName.substring(watchPolicyName.lastIndexOf('.')+1);
 171                                         watchPolicyName = watchPolicyName.substring(0, watchPolicyName.lastIndexOf('.')).replace(".", File.separator);
 172                                         String policyVersionName = watchPolicyName.replace(".", File.separator);
 173                                         watchPolicyName = watchPolicyName + "." + version + ".xml";
 174                                         PolicyVersion entityItem = new PolicyVersion();
 175                                         entityItem.setPolicyName(policyVersionName);
 176                                         entityItem.setActiveVersion(Integer.parseInt(version));
 177                                         entityItem.setModifiedBy(userId);
 178                                         email.sendMail(entityItem, watchPolicyName, mode, commonClassDao);
 179                                 }
 180                         }else{
 181                                 result =  "Response is null from PAP";
 182                         }
 183
 184                         response.setCharacterEncoding(PolicyController.getCharacterencoding());
 185                         response.setContentType(PolicyController.getContenttype());
 186                         request.setCharacterEncoding(PolicyController.getCharacterencoding());
 187
 188                         PrintWriter out = response.getWriter();
 189                         String responseString = mapper.writeValueAsString(result);
 190                         JSONObject j = new JSONObject("{policyData: " + responseString + "}");
 191                         out.write(j.toString());
 192                 }catch(Exception e){
 193                         policyLogger.error("Exception Occured while saving policy" , e);
 194                 }
 195         }
 196
 197
 198         private ResponseEntity<?> sendToPAP(String body, String requestURI, HttpMethod method){
 199                 String papUrl = PolicyController.getPapUrl();
 200                 String papID = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_USERID);
 201                 String papPass = CryptoUtils.decryptTxtNoExStr(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_PASS));
 202
 203                 Base64.Encoder encoder = Base64.getEncoder();
 204                 String encoding = encoder.encodeToString((papID+":"+papPass).getBytes(StandardCharsets.UTF_8));
 205                 HttpHeaders headers = new HttpHeaders();
 206                 headers.set("Authorization", "Basic " + encoding);
 207                 headers.set("Content-Type", PolicyController.getContenttype());
 208
 209                 RestTemplate restTemplate = new RestTemplate();
 210                 HttpEntity<?> requestEntity = new HttpEntity<>(body, headers);
 211                 ResponseEntity<?> result = null;
 212                 HttpClientErrorException exception = null;
 213                 String uri = requestURI;
 214                 if(uri.startsWith("/")){
 215                         uri = uri.substring(uri.indexOf('/')+1);
 216                 }
 217                 uri = "onap" + uri.substring(uri.indexOf('/'));
 218                 try{
 219                         result = restTemplate.exchange(papUrl + uri, method, requestEntity, String.class);
 220                 }catch(Exception e){
 221                         policyLogger.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error while connecting to " + papUrl, e);
 222                         exception = new HttpClientErrorException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage());
 223                         if("409 Conflict".equals(e.getMessage())){
 224                                 return ResponseEntity.ok(HttpServletResponse.SC_CONFLICT);
 225                         }
 226                 }
 227                 if(exception != null && exception.getStatusCode()!=null){
 228                         if(exception.getStatusCode().equals(HttpStatus.UNAUTHORIZED)){
 229                                 String message = XACMLErrorConstants.ERROR_PERMISSIONS +":"+exception.getStatusCode()+":" + "ERROR_AUTH_GET_PERM" ;
 230                                 policyLogger.error(message);
 231                         }
 232                         if(exception.getStatusCode().equals(HttpStatus.BAD_REQUEST)){
 233                                 String message = XACMLErrorConstants.ERROR_DATA_ISSUE + ":"+exception.getStatusCode()+":" + exception.getResponseBodyAsString();
 234                                 policyLogger.error(message);
 235                         }
 236                         if(exception.getStatusCode().equals(HttpStatus.NOT_FOUND)){
 237                                 String message = XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error while connecting to " + papUrl + exception;
 238                                 policyLogger.error(message);
 239                         }
 240                         String message = XACMLErrorConstants.ERROR_PROCESS_FLOW + ":"+exception.getStatusCode()+":" + exception.getResponseBodyAsString();
 241                         policyLogger.error(message);
 242                 }
 243                 return result;
 244         }
 245
 246         private String callPAP(HttpServletRequest request , String method, String uriValue){
 247                 String uri = uriValue;
 248                 String boundary = null;
 249                 String papUrl = PolicyController.getPapUrl();
 250                 String papID = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_USERID);
 251                 String papPass = CryptoUtils.decryptTxtNoExStr(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_PASS));
 252
 253                 Base64.Encoder encoder = Base64.getEncoder();
 254                 String encoding = encoder.encodeToString((papID+":"+papPass).getBytes(StandardCharsets.UTF_8));
 255                 HttpHeaders headers = new HttpHeaders();
 256                 headers.set("Authorization", "Basic " + encoding);
 257                 headers.set("Content-Type", PolicyController.getContenttype());
 258
 259
 260                 HttpURLConnection connection = null;
 261                 List<FileItem> items;
 262                 FileItem item = null;
 263                 File file = null;
 264                 if(uri.contains(importDictionary)){
 265                         try {
 266                                 items = new ServletFileUpload(new DiskFileItemFactory()).parseRequest(request);
 267                                 item = items.get(0);
 268                                 file = new File(item.getName());
 269                                 String newFile = file.toString();
 270                                 uri = uri +"&dictionaryName="+newFile;
 271                         } catch (Exception e2) {
 272                                 policyLogger.error("Exception Occured while calling PAP with import dictionary request"+e2);
 273                         }
 274                 }
 275
 276                 try {
 277                         URL url = new URL(papUrl + uri);
 278                         connection = (HttpURLConnection)url.openConnection();
 279                         connection.setRequestMethod(method);
 280                         connection.setUseCaches(false);
 281                         connection.setInstanceFollowRedirects(false);
 282                         connection.setRequestProperty("Authorization", "Basic " + encoding);
 283                         connection.setDoOutput(true);
 284                         connection.setDoInput(true);
 285
 286                         if(!uri.contains("searchPolicy?action=delete&")){
 287
 288                                 if(!(uri.endsWith("set_BRMSParamData") || uri.contains(importDictionary))){
 289                                         connection.setRequestProperty("Content-Type",PolicyController.getContenttype());
 290                                         ObjectMapper mapper = new ObjectMapper();
 291                                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 292                                         JsonNode root = null;
 293                                         try {
 294                                                 root = mapper.readTree(request.getReader());
 295                                         }catch (Exception e1) {
 296                                                 policyLogger.error("Exception Occured while calling PAP"+e1);
 297                                         }
 298
 299                                         ObjectMapper mapper1 = new ObjectMapper();
 300                                         mapper1.configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, true);
 301
 302                                         Object obj = mapper1.treeToValue(root, Object.class);
 303                                         String json = mapper1.writeValueAsString(obj);
 304
 305                                         Object content =  new ByteArrayInputStream(json.getBytes());
 306
 307                                         if (content instanceof InputStream) {
 308                                                 // send current configuration
 309                                                 try (OutputStream os = connection.getOutputStream()) {
 310                                                         int count = IOUtils.copy((InputStream) content, os);
 311                                                         if (policyLogger.isDebugEnabled()) {
 312                                                                 policyLogger.debug("copied to output, bytes=" + count);
 313                                                         }
 314                                                 }
 315                                         }
 316                                 }else{
 317                                         if(uri.endsWith("set_BRMSParamData")){
 318                                                 connection.setRequestProperty("Content-Type",PolicyController.getContenttype());
 319                                                 try (OutputStream os = connection.getOutputStream()) {
 320                                                         IOUtils.copy((InputStream) request.getInputStream(), os);
 321                                                 }
 322                                         }else{
 323                                                 boundary = "===" + System.currentTimeMillis() + "===";
 324                                                 connection.setRequestProperty("Content-Type","multipart/form-data; boundary=" + boundary);
 325                                                 try (OutputStream os = connection.getOutputStream()) {
 326                                                         if(item != null){
 327                                                                 IOUtils.copy((InputStream) item.getInputStream(), os);
 328                                                         }
 329                                                 }
 330                                         }
 331                                 }
 332                         }
 333
 334                         connection.connect();
 335
 336                         int responseCode = connection.getResponseCode();
 337                         if(responseCode == 200){
 338                                 // get the response content into a String
 339                                 String responseJson = null;
 340                                 // read the inputStream into a buffer (trick found online scans entire input looking for end-of-file)
 341                                 java.util.Scanner scanner = new java.util.Scanner(connection.getInputStream());
 342                                 scanner.useDelimiter("\\A");
 343                                 responseJson =  scanner.hasNext() ? scanner.next() : "";
 344                                 scanner.close();
 345                                 policyLogger.info("JSON response from PAP: " + responseJson);
 346                                 return responseJson;
 347                         }
 348
 349                 } catch (Exception e) {
 350                         policyLogger.error("Exception Occured"+e);
 351                 }finally{
 352                         if(file != null && file.exists() && file.delete()){
 353                                 policyLogger.info("File Deleted Successfully");
 354                         }
 355                         if (connection != null) {
 356                                 try {
 357                                         // For some reason trying to get the inputStream from the connection
 358                                         // throws an exception rather than returning null when the InputStream does not exist.
 359                                         InputStream is = connection.getInputStream();
 360                                         if (is != null) {
 361                                                 is.close();
 362                                         }
 363                                 } catch (IOException ex) {
 364                                         policyLogger.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Failed to close connection: " + ex, ex);
 365                                 }
 366                                 connection.disconnect();
 367                         }
 368                 }
 369                 return null;
 370         }
 371
 372         @RequestMapping(value={"/getDictionary/*"}, method={RequestMethod.GET})
 373         public void getDictionaryController(HttpServletRequest request, HttpServletResponse response){
 374                 String uri = request.getRequestURI().replace("/getDictionary", "");
 375                 String body;
 376                 ResponseEntity<?> responseEntity = sendToPAP(null, uri, HttpMethod.GET);
 377                 if(responseEntity != null){
 378                         body = responseEntity.getBody().toString();
 379                 }else{
 380                         body = "";
 381                 }
 382                 try {
 383                         response.getWriter().write(body);
 384                 } catch (IOException e) {
 385                         policyLogger.error("Exception occured while getting Dictionary entries", e);
 386                 }
 387         }
 388
 389         @RequestMapping(value={"/saveDictionary/*/*"}, method={RequestMethod.POST})
 390         public void saveDictionaryController(HttpServletRequest request, HttpServletResponse response) throws IOException{
 391                 String userId = "";
 392                 String uri = request.getRequestURI().replace("/saveDictionary", "");
 393                 if(uri.startsWith("/")){
 394                         uri = uri.substring(uri.indexOf('/')+1);
 395                 }
 396                 uri = "/onap" + uri.substring(uri.indexOf('/'));
 397                 if(uri.contains(importDictionary)){
 398                         userId = UserUtils.getUserSession(request).getOrgUserId();
 399                         uri = uri+ "?userId=" +userId;
 400                 }
 401
 402                 policyLogger.info("****************************************Logging UserID while Saving Dictionary*****************************************************");
 403                 policyLogger.info("UserId:  " + userId);
 404                 policyLogger.info("***********************************************************************************************************************************");
 405
 406                 String body = callPAP(request, "POST", uri.replaceFirst("/", "").trim());
 407                 if(body != null && !body.isEmpty()){
 408                         response.getWriter().write(body);
 409                 }else{
 410                         response.getWriter().write("Failed");
 411                 }
 412         }
 413
 414         @RequestMapping(value={"/deleteDictionary/*/*"}, method={RequestMethod.POST})
 415         public void deletetDictionaryController(HttpServletRequest request, HttpServletResponse response) throws IOException {
 416                 String uri = request.getRequestURI().replace("/deleteDictionary", "");
 417                 if(uri.startsWith("/")){
 418                         uri = uri.substring(uri.indexOf('/')+1);
 419                 }
 420                 uri = "/onap" + uri.substring(uri.indexOf('/'));
 421
 422                 String userId = UserUtils.getUserSession(request).getOrgUserId();
 423                 policyLogger.info("****************************************Logging UserID while Deleting Dictionary*****************************************************");
 424                 policyLogger.info("UserId:  " + userId);
 425                 policyLogger.info("*************************************************************************************************************************************");
 426
 427                 String body = callPAP(request, "POST", uri.replaceFirst("/", "").trim());
 428                 if(body != null && !body.isEmpty()){
 429                         response.getWriter().write(body);
 430                 }else{
 431                         response.getWriter().write("Failed");
 432                 }
 433         }
 434
 435         @RequestMapping(value={"/searchDictionary"}, method={RequestMethod.POST})
 436         public ModelAndView searchDictionaryController(HttpServletRequest request, HttpServletResponse response) throws IOException {
 437                 Object resultList;
 438                 String uri = request.getRequestURI();
 439                 if(uri.startsWith("/")){
 440                         uri = uri.substring(uri.indexOf('/')+1);
 441                 }
 442                 uri = "/onap" + uri.substring(uri.indexOf('/'));
 443                 try{
 444                         String body = callPAP(request, "POST", uri.replaceFirst("/", "").trim());
 445                         if(body.contains("CouldNotConnectException")){
 446                                 List<String> data = new ArrayList<>();
 447                                 data.add("Elastic Search Server is down");
 448                                 resultList = data;
 449                         }else{
 450                                 JSONObject json = new JSONObject(body);
 451                                 resultList = json.get("policyresult");
 452                         }
 453                 }catch(Exception e){
 454                         policyLogger.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Exception Occured while querying Elastic Search: " + e);
 455                         List<String> data = new ArrayList<>();
 456                         data.add("Elastic Search Server is down");
 457                         resultList = data;
 458                 }
 459
 460                 response.setCharacterEncoding(PolicyController.getCharacterencoding());
 461                 response.setContentType(PolicyController.getContenttype());
 462                 PrintWriter out = response.getWriter();
 463                 JSONObject j = new JSONObject("{result: " + resultList + "}");
 464                 out.write(j.toString());
 465                 return null;
 466         }
 467
 468         @RequestMapping(value={"/searchPolicy"}, method={RequestMethod.POST})
 469         public ModelAndView searchPolicy(HttpServletRequest request, HttpServletResponse response) throws IOException{
 470                 Object resultList;
 471                 String uri = request.getRequestURI()+"?action=search";
 472                 if(uri.startsWith("/")){
 473                         uri = uri.substring(uri.indexOf('/')+1);
 474                 }
 475                 uri = "/onap" + uri.substring(uri.indexOf('/'));
 476                 String body = callPAP(request, "POST", uri.replaceFirst("/", "").trim());
 477
 478                 JSONObject json = new JSONObject(body);
 479                 try{
 480                         resultList = json.get("policyresult");
 481                 }catch(Exception e){
 482                         List<String> data = new ArrayList<>();
 483                         resultList = json.get("data");
 484                         data.add("Exception");
 485                         data.add(resultList.toString());
 486                         resultList = data;
 487                         policyLogger.error("Exception Occured while searching for Policy in Elastic Database" +e);
 488                 }
 489
 490                 response.setCharacterEncoding("UTF-8");
 491                 response.setContentType("application / json");
 492                 request.setCharacterEncoding("UTF-8");
 493
 494                 PrintWriter out = response.getWriter();
 495                 JSONObject j = new JSONObject("{result: " + resultList + "}");
 496                 out.write(j.toString());
 497                 return null;
 498         }
 499
 500         public void deleteElasticData(String fileName){
 501                 String uri = "searchPolicy?action=delete&policyName='"+fileName+"'";
 502                 callPAP(null, "POST", uri.trim());
 503         }
 504
 505         public String notifyOtherPAPSToUpdateConfigurations(String mode, String newName, String oldName){
 506                 String uri = "onap/notifyOtherPAPs?action="+mode+"&newPolicyName="+newName+"&oldPolicyName="+oldName+"";
 507                 return callPAP(null, "POST", uri.trim());
 508         }
 509
 510 }