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