ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/BRMSDictionaryController.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP-PAP-REST
   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
  21 package org.onap.policy.pap.xacml.rest.controller;
  22
  23 import java.io.IOException;
  24 import java.io.PrintWriter;
  25 import java.io.StringWriter;
  26 import java.nio.charset.StandardCharsets;
  27 import java.util.Date;
  28 import java.util.HashMap;
  29 import java.util.List;
  30 import java.util.Map;
  31
  32 import javax.servlet.http.HttpServletRequest;
  33 import javax.servlet.http.HttpServletResponse;
  34
  35 import org.apache.commons.io.IOUtils;
  36 import org.json.JSONObject;
  37 import org.onap.policy.api.PEDependency;
  38 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  39 import org.onap.policy.common.logging.flexlogger.Logger;
  40 import org.onap.policy.pap.xacml.rest.util.JsonMessage;
  41 import org.onap.policy.rest.dao.CommonClassDao;
  42 import org.onap.policy.rest.jpa.BRMSController;
  43 import org.onap.policy.rest.jpa.BRMSDependency;
  44 import org.onap.policy.rest.jpa.BRMSParamTemplate;
  45 import org.onap.policy.rest.jpa.UserInfo;
  46 import org.onap.policy.utils.PolicyUtils;
  47 import org.onap.policy.xacml.api.XACMLErrorConstants;
  48 import org.springframework.beans.factory.annotation.Autowired;
  49 import org.springframework.http.MediaType;
  50 import org.springframework.stereotype.Controller;
  51 import org.springframework.web.bind.annotation.RequestMapping;
  52 import org.springframework.web.servlet.ModelAndView;
  53
  54 import com.fasterxml.jackson.databind.DeserializationFeature;
  55 import com.fasterxml.jackson.databind.JsonNode;
  56 import com.fasterxml.jackson.databind.ObjectMapper;
  57
  58
  59 @Controller
  60 public class BRMSDictionaryController{
  61
  62         private static final Logger LOGGER  = FlexLogger.getLogger(BRMSDictionaryController.class);
  63
  64
  65         private static CommonClassDao commonClassDao;
  66         private static String rule;
  67         private static String utf8 = "UTF-8";
  68         private static String applicationJsonContentType = "application / json";
  69         private static String successMsg = "Success";
  70         private static String successMessage = "success";
  71         private static String duplicateResponseString = "Duplicate";
  72         private static String ruleName = "ruleName";
  73         private static String successMapKey = "successMapKey";
  74         private static String errorMsg  = "error";
  75         private static String errorMessage      = "Error";
  76         private static String dictionaryDBQuery = "dictionaryDBQuery";
  77         private static String operation = "operation";
  78         private static String getDictionary =  "getDictionary";
  79         private static String apiflag = "apiflag";
  80         private static String dictionaryFields ="dictionaryFields";
  81         private static String update = "update";
  82         private static String userid = "userid";
  83         private static String dependencyName = "dependencyName";
  84         private static String controllerName = "controllerName";
  85         @Autowired
  86         public BRMSDictionaryController(CommonClassDao commonClassDao){
  87                 BRMSDictionaryController.commonClassDao = commonClassDao;
  88         }
  89         public static void setCommonClassDao(CommonClassDao commonClassDao2) {
  90                 BRMSDictionaryController.commonClassDao = commonClassDao2;
  91         }
  92         /*
  93          * This is an empty constructor
  94          */
  95         public BRMSDictionaryController() {}
  96
  97         public UserInfo getUserInfo(String loginId){
  98                 return (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId", loginId);
  99         }
 100
 101         @RequestMapping(value={"/get_BRMSParamDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 102         public void getBRMSParamDictionaryByNameEntityData(HttpServletResponse response){
 103                 try{
 104                         Map<String, Object> model = new HashMap<>();
 105                         ObjectMapper mapper = new ObjectMapper();
 106                         model.put("brmsParamDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(BRMSParamTemplate.class, ruleName)));
 107                         JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
 108                         JSONObject j = new JSONObject(msg);
 109                         response.getWriter().write(j.toString());
 110                 }
 111                 catch (Exception e){
 112                          LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
 113                 }
 114         }
 115
 116         @RequestMapping(value={"/get_BRMSParamData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 117         public void getBRMSParamDictionaryEntityData(HttpServletResponse response){
 118                 try{
 119                         Map<String, Object> model = new HashMap<>();
 120                         ObjectMapper mapper = new ObjectMapper();
 121                         model.put("brmsParamDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(BRMSParamTemplate.class)));
 122                         JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
 123                         JSONObject j = new JSONObject(msg);
 124             response.addHeader(successMapKey, successMessage);
 125             response.addHeader(operation, getDictionary);
 126                         response.getWriter().write(j.toString());
 127                 }
 128                 catch (Exception e){
 129                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
 130                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 131                         response.addHeader(errorMsg, dictionaryDBQuery);
 132                 }
 133         }
 134
 135         @RequestMapping(value={"/brms_dictionary/set_BRMSParamData"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
 136         public static void setRuleData(HttpServletRequest request) throws IOException{
 137                 StringWriter writer = new StringWriter();
 138                 IOUtils.copy(request.getInputStream() , writer, StandardCharsets.UTF_8);
 139                 String cleanStreamBoundary =  writer.toString().replaceFirst("------(.*)(?s).*octet-stream", "");
 140                 rule = cleanStreamBoundary.substring(0, cleanStreamBoundary.lastIndexOf("end")+4);
 141         }
 142
 143         @RequestMapping(value={"/brms_dictionary/save_BRMSParam"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
 144         public ModelAndView saveBRMSParamDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException {
 145                 try {
 146                         boolean duplicateflag = false;
 147             boolean fromAPI = false;
 148             if (request.getParameter(apiflag)!=null && ("api").equalsIgnoreCase(request.getParameter(apiflag))) {
 149                 fromAPI = true;
 150             }
 151                         ObjectMapper mapper = new ObjectMapper();
 152                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 153                         JsonNode root = mapper.readTree(request.getReader());
 154
 155             BRMSParamTemplate bRMSParamTemplateData;
 156             String userId = null;
 157             if(fromAPI) {
 158                 bRMSParamTemplateData = (BRMSParamTemplate)mapper.readValue(root.get(dictionaryFields).toString(), BRMSParamTemplate.class);
 159                 userId = "API";
 160
 161                 //check if update operation or create, get id for data to be updated and update attributeData
 162                 if ((update).equals(request.getParameter(operation))) {
 163                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(bRMSParamTemplateData.getRuleName(), ruleName, BRMSParamTemplate.class);
 164                         BRMSParamTemplate data = (BRMSParamTemplate) duplicateData.get(0);
 165                         int id = data.getId();
 166                         bRMSParamTemplateData.setId(id);
 167                         bRMSParamTemplateData.setUserCreatedBy(this.getUserInfo(userId));
 168                 }
 169             } else {
 170                 bRMSParamTemplateData = (BRMSParamTemplate)mapper.readValue(root.get("brmsParamDictionaryData").toString(), BRMSParamTemplate.class);
 171                 userId = root.get(userid).textValue();
 172             }
 173
 174                         bRMSParamTemplateData.setRule(rule);
 175                         if(bRMSParamTemplateData.getId() == 0){
 176                                 List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(bRMSParamTemplateData.getRuleName(), ruleName, BRMSParamTemplate.class);
 177                                 if(!duplicateData.isEmpty()){
 178                                         duplicateflag = true;
 179                                 }else{
 180                                         bRMSParamTemplateData.setUserCreatedBy(this.getUserInfo(userId));
 181                                         commonClassDao.save(bRMSParamTemplateData);
 182                                 }
 183                         }else{
 184                                 commonClassDao.update(bRMSParamTemplateData);
 185                         }
 186                         response.setCharacterEncoding(utf8);
 187                         response.setContentType(applicationJsonContentType);
 188                         request.setCharacterEncoding(utf8);
 189
 190                         String responseString = "";
 191                         if(duplicateflag){
 192                                 responseString = duplicateResponseString;
 193                         }else{
 194                                 responseString = mapper.writeValueAsString(BRMSDictionaryController.commonClassDao.getData(BRMSParamTemplate.class));
 195                         }
 196             if(fromAPI) {
 197                 if (responseString!=null && !(duplicateResponseString).equals(responseString)) {
 198                     responseString = successMsg;
 199                 }
 200                 ModelAndView result = new ModelAndView();
 201                 result.setViewName(responseString);
 202                 return result;
 203             } else {
 204                 response.setCharacterEncoding(utf8);
 205                 response.setContentType(applicationJsonContentType);
 206                 request.setCharacterEncoding(utf8);
 207
 208                 PrintWriter out = response.getWriter();
 209                 JSONObject j = new JSONObject("{brmsParamDictionaryDatas: " + responseString + "}");
 210                 out.write(j.toString());
 211                 return null;
 212             }
 213                 }
 214                 catch (Exception e){
 215                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
 216                         response.setCharacterEncoding(utf8);
 217                         request.setCharacterEncoding(utf8);
 218                         PrintWriter out = response.getWriter();
 219                         out.write(e.getMessage());
 220                 }
 221                 return null;
 222         }
 223
 224         @RequestMapping(value={"/brms_dictionary/remove_brmsParam"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
 225         public ModelAndView removeBRMSParamDictionary(HttpServletRequest request, HttpServletResponse response)throws IOException {
 226                 try{
 227                         ObjectMapper mapper = new ObjectMapper();
 228                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 229                         JsonNode root = mapper.readTree(request.getReader());
 230                         BRMSParamTemplate bRMSParamTemplateData = (BRMSParamTemplate)mapper.readValue(root.get("data").toString(), BRMSParamTemplate.class);
 231                         commonClassDao.delete(bRMSParamTemplateData);
 232                         response.setCharacterEncoding(utf8);
 233                         response.setContentType(applicationJsonContentType);
 234                         request.setCharacterEncoding(utf8);
 235
 236                         PrintWriter out = response.getWriter();
 237
 238                         String responseString = mapper.writeValueAsString(BRMSDictionaryController.commonClassDao.getData(BRMSParamTemplate.class));
 239                         JSONObject j = new JSONObject("{brmsParamDictionaryDatas: " + responseString + "}");
 240                         out.write(j.toString());
 241
 242                         return null;
 243                 }
 244                 catch (Exception e){
 245                          LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
 246                         response.setCharacterEncoding(utf8);
 247                         request.setCharacterEncoding(utf8);
 248                         PrintWriter out = response.getWriter();
 249                         out.write(e.getMessage());
 250                 }
 251                 return null;
 252         }
 253
 254     @RequestMapping(value={"/get_BRMSDependencyDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 255     public void getBRMSDependencyDictionaryByNameEntityData(HttpServletResponse response){
 256         try{
 257             Map<String, Object> model = new HashMap<>();
 258             ObjectMapper mapper = new ObjectMapper();
 259             model.put("brmsDependencyDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(BRMSDependency.class, dependencyName)));
 260             JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
 261             JSONObject j = new JSONObject(msg);
 262             response.getWriter().write(j.toString());
 263         }
 264         catch (Exception e){
 265             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
 266         }
 267     }
 268
 269     @RequestMapping(value={"/get_BRMSDependencyData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 270     public void getBRMSDependencyDictionaryEntityData(HttpServletResponse response){
 271         try{
 272             Map<String, Object> model = new HashMap<>();
 273             ObjectMapper mapper = new ObjectMapper();
 274             model.put("brmsDependencyDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(BRMSDependency.class)));
 275             JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
 276             JSONObject j = new JSONObject(msg);
 277             response.addHeader(successMapKey, successMessage);
 278             response.addHeader(operation, getDictionary);
 279             response.getWriter().write(j.toString());
 280         }
 281         catch (Exception e){
 282             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
 283             response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 284             response.addHeader(errorMsg, dictionaryDBQuery);
 285         }
 286     }
 287
 288     @RequestMapping(value={"/brms_dictionary/save_BRMSDependencyData"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
 289     public ModelAndView saveBRMSDependencyDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException {
 290         try {
 291             boolean duplicateflag = false;
 292             LOGGER.debug("DictionaryController:  saveBRMSDependencyDictionary() is called");
 293
 294             boolean fromAPI = false;
 295             if (request.getParameter(apiflag)!=null && ("api").equalsIgnoreCase(request.getParameter(apiflag))) {
 296                 fromAPI = true;
 297             }
 298
 299             ObjectMapper mapper = new ObjectMapper();
 300             mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 301             JsonNode root = mapper.readTree(request.getReader());
 302
 303             BRMSDependency brmsDependency;
 304             String userId = null;
 305             if (fromAPI) {
 306                 brmsDependency = (BRMSDependency)mapper.readValue(root.get(dictionaryFields).toString(), BRMSDependency.class);
 307                 userId = "API";
 308
 309                 //check if update operation or create, get id for data to be updated
 310                 if ((update).equals(request.getParameter(operation))) {
 311                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(brmsDependency.getDependencyName(), dependencyName, BRMSDependency.class);
 312                         BRMSDependency data = (BRMSDependency) duplicateData.get(0);
 313                         int id = data.getId();
 314                         brmsDependency.setId(id);
 315                         brmsDependency.setUserCreatedBy(this.getUserInfo(userId));
 316                 }
 317             } else {
 318                 brmsDependency = (BRMSDependency)mapper.readValue(root.get("brmsDependencyDictionaryData").toString(), BRMSDependency.class);
 319                 userId = root.get(userid).textValue();
 320             }
 321
 322             LOGGER.audit("the userId from the onap portal is: " + userId);
 323             String responseString = null;
 324
 325             if(brmsDependency.getDependency()!=null && !("").equals(brmsDependency.getDependency().trim())){
 326                 PEDependency dependency = null;
 327                 try{
 328                     dependency = PolicyUtils.jsonStringToObject(brmsDependency.getDependency(), PEDependency.class);
 329                 }catch(Exception e){
 330                     LOGGER.error(XACMLErrorConstants.ERROR_SCHEMA_INVALID + "wrong data given for BRMS PEDependency Dictionary : " + brmsDependency.getDependency(),e);
 331                 }
 332                 if(dependency==null){
 333                     responseString = errorMessage;
 334                 }else{
 335                     if(brmsDependency.getId() == 0){
 336                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(brmsDependency.getDependencyName(), dependencyName, BRMSDependency.class);
 337                         if(!duplicateData.isEmpty()){
 338                             duplicateflag = true;
 339                         }else{
 340                             brmsDependency.setUserCreatedBy(getUserInfo(userId));
 341                             brmsDependency.setUserModifiedBy(getUserInfo(userId));
 342                             LOGGER.audit("DictionaryController:  got the user info now about to call Save() method on brmsDependencydao");
 343                             commonClassDao.save(brmsDependency);
 344                         }
 345                     }else{
 346                         brmsDependency.setUserModifiedBy(this.getUserInfo(userId));
 347                         brmsDependency.setModifiedDate(new Date());
 348                         commonClassDao.update(brmsDependency);
 349                     }
 350                     if(duplicateflag) {
 351                         responseString = duplicateResponseString;
 352                     } else {
 353                         responseString = mapper.writeValueAsString(commonClassDao.getData(BRMSDependency.class));
 354                     }
 355                 }
 356             }
 357             if (fromAPI) {
 358                 if (responseString!=null && !(duplicateResponseString).equals(responseString) && !(errorMessage).equals(responseString)) {
 359                     responseString = successMsg;
 360                 }
 361                 ModelAndView result = new ModelAndView();
 362                 result.setViewName(responseString);
 363                 return result;
 364             } else {
 365                 response.setCharacterEncoding(utf8);
 366                 response.setContentType(applicationJsonContentType);
 367                 request.setCharacterEncoding(utf8);
 368                 PrintWriter out = response.getWriter();
 369                 JSONObject j = new JSONObject("{brmsDependencyDictionaryDatas: " + responseString + "}");
 370                 out.write(j.toString());
 371
 372                 return null;
 373             }
 374         } catch (Exception e){
 375             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
 376             response.setCharacterEncoding(utf8);
 377             request.setCharacterEncoding(utf8);
 378             PrintWriter out = response.getWriter();
 379             out.write(e.getMessage());
 380         }
 381         return null;
 382     }
 383
 384     @RequestMapping(value={"/brms_dictionary/remove_brmsDependency"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
 385     public ModelAndView removeBRMSDependencyDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException {
 386         try{
 387             ObjectMapper mapper = new ObjectMapper();
 388             mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 389             JsonNode root = mapper.readTree(request.getReader());
 390             BRMSDependency brmsDependency = (BRMSDependency)mapper.readValue(root.get("data").toString(), BRMSDependency.class);
 391             commonClassDao.delete(brmsDependency);
 392             response.setCharacterEncoding(utf8);
 393             response.setContentType(applicationJsonContentType);
 394             request.setCharacterEncoding(utf8);
 395             PrintWriter out = response.getWriter();
 396             String responseString = mapper.writeValueAsString(commonClassDao.getData(BRMSDependency.class));
 397             JSONObject j = new JSONObject("{brmsDependencyDictionaryDatas: " + responseString + "}");
 398             out.write(j.toString());
 399             return null;
 400         }
 401         catch (Exception e){
 402             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
 403             response.setCharacterEncoding(utf8);
 404             request.setCharacterEncoding(utf8);
 405             PrintWriter out = response.getWriter();
 406             out.write(e.getMessage());
 407         }
 408         return null;
 409     }
 410
 411
 412     @RequestMapping(value={"/get_BRMSControllerDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 413     public void getBRMSControllerDictionaryByNameEntityData(HttpServletResponse response){
 414         try{
 415             Map<String, Object> model = new HashMap<>();
 416             ObjectMapper mapper = new ObjectMapper();
 417             model.put("brmsControllerDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(BRMSController.class, controllerName)));
 418             JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
 419             JSONObject j = new JSONObject(msg);
 420             response.getWriter().write(j.toString());
 421         }
 422         catch (Exception e){
 423             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
 424         }
 425     }
 426
 427     @RequestMapping(value={"/get_BRMSControllerData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 428     public void getBRMSControllerDictionaryEntityData(HttpServletResponse response){
 429         try{
 430             Map<String, Object> model = new HashMap<>();
 431             ObjectMapper mapper = new ObjectMapper();
 432             model.put("brmsControllerDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(BRMSController.class)));
 433             JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
 434             JSONObject j = new JSONObject(msg);
 435             response.addHeader(successMapKey, successMessage);
 436             response.addHeader(operation, getDictionary);
 437             response.getWriter().write(j.toString());
 438         }
 439         catch (Exception e){
 440             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
 441             response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 442             response.addHeader(errorMsg, dictionaryDBQuery);
 443         }
 444     }
 445
 446     @RequestMapping(value={"/brms_dictionary/save_BRMSControllerData"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
 447     public ModelAndView saveBRMSControllerDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 448         try {
 449             boolean duplicateflag = false;
 450             LOGGER.debug("DictionaryController:  saveBRMSControllerDictionary() is called");
 451             boolean fromAPI = false;
 452             if (request.getParameter(apiflag)!=null && ("api").equalsIgnoreCase(request.getParameter(apiflag))) {
 453                 fromAPI = true;
 454             }
 455             ObjectMapper mapper = new ObjectMapper();
 456             mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 457             JsonNode root = mapper.readTree(request.getReader());
 458             BRMSController brmsController;
 459             String userId = null;
 460             if (fromAPI) {
 461                 brmsController = (BRMSController)mapper.readValue(root.get(dictionaryFields).toString(), BRMSController.class);
 462                 userId = "API";
 463                 //check if update operation or create, get id for data to be updated
 464                 if ((update).equals(request.getParameter(operation))) {
 465                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(brmsController.getControllerName(), controllerName, BRMSController.class);
 466                         BRMSController data = (BRMSController) duplicateData.get(0);
 467                         int id = data.getId();
 468                         brmsController.setId(id);
 469                         brmsController.setUserCreatedBy(this.getUserInfo(userId));
 470                 }
 471             } else {
 472                 brmsController = (BRMSController)mapper.readValue(root.get("brmsControllerDictionaryData").toString(), BRMSController.class);
 473                 userId = root.get(userid).textValue();
 474             }
 475             LOGGER.audit("the userId from the onap portal is: " + userId);
 476             String responseString = null;
 477             if(brmsController.getController()!=null && !("").equals(brmsController.getController().trim())){
 478                 PEDependency dependency = null;
 479                 try{
 480                     dependency = PolicyUtils.jsonStringToObject(brmsController.getController(), PEDependency.class);
 481                 }catch(Exception e){
 482                     LOGGER.error(XACMLErrorConstants.ERROR_SCHEMA_INVALID + "wrong data given for BRMS Controller Dictionary : " + brmsController.getController(),e);
 483                 }
 484                 if(dependency==null){
 485                     responseString = errorMessage;
 486                 }else{
 487                     if(brmsController.getId() == 0){
 488                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(brmsController.getControllerName(), controllerName, BRMSController.class);
 489                         if(!duplicateData.isEmpty()){
 490                             duplicateflag = true;
 491                         }else{
 492                             brmsController.setUserCreatedBy(getUserInfo(userId));
 493                             brmsController.setUserModifiedBy(getUserInfo(userId));
 494                             LOGGER.audit("DictionaryController:  got the user info now about to call Save() method on brmsControllerdao");
 495                             commonClassDao.save(brmsController);
 496                         }
 497                     }else{
 498                         brmsController.setUserModifiedBy(this.getUserInfo(userId));
 499                         brmsController.setModifiedDate(new Date());
 500                         commonClassDao.update(brmsController);
 501                     }
 502                     if(duplicateflag) {
 503                         responseString = duplicateResponseString;
 504                     } else {
 505                         responseString = mapper.writeValueAsString(commonClassDao.getData(BRMSController.class));
 506                     }
 507                 }
 508             }
 509             if (fromAPI) {
 510                 if (responseString!=null && !(duplicateResponseString).equals(responseString) && !(errorMessage).equals(responseString)) {
 511                     responseString = successMsg;
 512                 }
 513                 ModelAndView result = new ModelAndView();
 514                 result.setViewName(responseString);
 515                 return result;
 516             } else {
 517                 response.setCharacterEncoding(utf8);
 518                 response.setContentType(applicationJsonContentType);
 519                 request.setCharacterEncoding(utf8);
 520                 PrintWriter out = response.getWriter();
 521                 JSONObject j = new JSONObject("{brmsControllerDictionaryDatas: " + responseString + "}");
 522                 out.write(j.toString());
 523                 return null;
 524             }
 525         } catch (Exception e){
 526             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
 527             response.setCharacterEncoding(utf8);
 528             request.setCharacterEncoding(utf8);
 529             PrintWriter out = response.getWriter();
 530             out.write(e.getMessage());
 531         }
 532         return null;
 533     }
 534
 535     @RequestMapping(value={"/brms_dictionary/remove_brmsController"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
 536     public ModelAndView removeBRMSControllerDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 537         try{
 538             ObjectMapper mapper = new ObjectMapper();
 539             mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 540             JsonNode root = mapper.readTree(request.getReader());
 541             BRMSController brmsController = (BRMSController)mapper.readValue(root.get("data").toString(), BRMSController.class);
 542             commonClassDao.delete(brmsController);
 543             response.setCharacterEncoding(utf8);
 544             response.setContentType(applicationJsonContentType);
 545             request.setCharacterEncoding(utf8);
 546             PrintWriter out = response.getWriter();
 547             String responseString = mapper.writeValueAsString(commonClassDao.getData(BRMSController.class));
 548             JSONObject j = new JSONObject("{brmsControllerDictionaryDatas: " + responseString + "}");
 549             out.write(j.toString());
 550             return null;
 551         }
 552         catch (Exception e){
 553             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
 554             response.setCharacterEncoding(utf8);
 555             request.setCharacterEncoding(utf8);
 556             PrintWriter out = response.getWriter();
 557             out.write(e.getMessage());
 558         }
 559         return null;
 560     }
 561
 562     public BRMSDependency getDependencyDataByID(String dependencyName){
 563         return (BRMSDependency) commonClassDao.getEntityItem(BRMSDependency.class, dependencyName, dependencyName);
 564     }
 565
 566     public BRMSController getControllerDataByID(String controllerName){
 567         return (BRMSController) commonClassDao.getEntityItem(BRMSController.class, controllerName, controllerName);
 568     }
 569
 570 }