ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/ClosedLoopDictionaryController.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.util.Date;
  25 import java.util.List;
  26
  27 import javax.servlet.http.HttpServletRequest;
  28 import javax.servlet.http.HttpServletResponse;
  29
  30 import org.onap.policy.pap.xacml.rest.adapters.GridData;
  31 import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl;
  32 import org.onap.policy.pap.xacml.rest.util.DictionaryUtils;
  33 import org.onap.policy.rest.dao.CommonClassDao;
  34 import org.onap.policy.rest.jpa.ClosedLoopD2Services;
  35 import org.onap.policy.rest.jpa.ClosedLoopSite;
  36 import org.onap.policy.rest.jpa.OnapName;
  37 import org.onap.policy.rest.jpa.PEPOptions;
  38 import org.onap.policy.rest.jpa.UserInfo;
  39 import org.onap.policy.rest.jpa.VNFType;
  40 import org.onap.policy.rest.jpa.VSCLAction;
  41 import org.onap.policy.rest.jpa.VarbindDictionary;
  42 import org.springframework.beans.factory.annotation.Autowired;
  43 import org.springframework.http.MediaType;
  44 import org.springframework.stereotype.Controller;
  45 import org.springframework.web.bind.annotation.RequestMapping;
  46 import org.springframework.web.bind.annotation.RequestMethod;
  47 import org.springframework.web.servlet.ModelAndView;
  48
  49 import com.fasterxml.jackson.databind.DeserializationFeature;
  50 import com.fasterxml.jackson.databind.JsonNode;
  51 import com.fasterxml.jackson.databind.ObjectMapper;
  52
  53 @Controller
  54 public class ClosedLoopDictionaryController{
  55
  56     private static CommonClassDao commonClassDao;
  57     private static String vsclaction = "vsclaction";
  58     private static String operation = "operation";
  59     private static String vnftype = "vnftype";
  60     private static String pepName = "pepName";
  61     private static String varbindName = "varbindName";
  62     private static String serviceName = "serviceName";
  63     private static String siteName = "siteName";
  64     private static String dictionaryFields = "dictionaryFields";
  65     private static String duplicateResponseString = "Duplicate";
  66     private static String userid = "userid";
  67     private static String vsclActionDatas = "vsclActionDictionaryDatas";
  68     private static String vnfTypeDatas = "vnfTypeDictionaryDatas";
  69     private static String pepOptionDatas = "pepOptionsDictionaryDatas";
  70     private static String varbindDatas = "varbindDictionaryDatas";
  71     private static String closedLoopDatas = "closedLoopServiceDictionaryDatas";
  72     private static String closedLoopSiteDatas = "closedLoopSiteDictionaryDatas";
  73
  74     @Autowired
  75     public ClosedLoopDictionaryController(CommonClassDao commonClassDao){
  76         ClosedLoopDictionaryController.commonClassDao = commonClassDao;
  77     }
  78
  79     public void setCommonClassDao(CommonClassDao commonClassDao){
  80         ClosedLoopDictionaryController.commonClassDao = commonClassDao;
  81     }
  82
  83     public static void setCommonClassDao(CommonClassDaoImpl commonClassDaoImpl) {
  84         commonClassDao = commonClassDaoImpl;
  85     }
  86
  87     public ClosedLoopDictionaryController(){
  88         super();
  89     }
  90
  91     private DictionaryUtils getDictionaryUtilsInstance(){
  92         return DictionaryUtils.getDictionaryUtils();
  93     }
  94
  95     @RequestMapping(value={"/get_VSCLActionDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
  96     public void getVSCLActionDictionaryByNameEntityData(HttpServletResponse response){
  97         DictionaryUtils utils = getDictionaryUtilsInstance();
  98         utils.getDataByEntity(response, vsclActionDatas, vsclaction, VSCLAction.class);
  99     }
 100
 101
 102     @RequestMapping(value={"/get_VSCLActionData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 103     public void getVSCLActionDictionaryEntityData(HttpServletResponse response){
 104         DictionaryUtils utils = getDictionaryUtilsInstance();
 105         utils.getData(response, vsclActionDatas, VSCLAction.class);
 106     }
 107
 108     @RequestMapping(value={"/get_VNFTypeDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 109     public void getVNFTypeDictionaryByNameEntityData(HttpServletResponse response){
 110         DictionaryUtils utils = getDictionaryUtilsInstance();
 111         utils.getDataByEntity(response, vnfTypeDatas, vnftype, VNFType.class);
 112     }
 113
 114     @RequestMapping(value={"/get_VNFTypeData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 115     public void getVNFTypeDictionaryEntityData(HttpServletResponse response){
 116         DictionaryUtils utils = getDictionaryUtilsInstance();
 117         utils.getData(response, vnfTypeDatas, VNFType.class);
 118     }
 119
 120     @RequestMapping(value={"/get_PEPOptionsDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 121     public void getPEPOptionsDictionaryByNameEntityData(HttpServletResponse response){
 122         DictionaryUtils utils = getDictionaryUtilsInstance();
 123         utils.getDataByEntity(response, pepOptionDatas, pepName, PEPOptions.class);
 124     }
 125
 126     @RequestMapping(value={"/get_PEPOptionsData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 127     public void getPEPOptionsDictionaryEntityData(HttpServletResponse response){
 128         DictionaryUtils utils = getDictionaryUtilsInstance();
 129         utils.getData(response, pepOptionDatas, PEPOptions.class);
 130     }
 131
 132     @RequestMapping(value={"/get_VarbindDictionaryDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 133     public void getVarbindDictionaryByNameEntityData(HttpServletResponse response){
 134         DictionaryUtils utils = getDictionaryUtilsInstance();
 135         utils.getDataByEntity(response, varbindDatas, varbindName, VarbindDictionary.class);
 136     }
 137
 138     @RequestMapping(value={"/get_VarbindDictionaryData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 139     public void getVarbindDictionaryEntityData(HttpServletResponse response){
 140         DictionaryUtils utils = getDictionaryUtilsInstance();
 141         utils.getData(response, varbindDatas, VarbindDictionary.class);
 142     }
 143
 144     @RequestMapping(value={"/get_ClosedLoopServicesDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 145     public void getClosedLoopServiceDictionaryByNameEntityData(HttpServletResponse response){
 146         DictionaryUtils utils = getDictionaryUtilsInstance();
 147         utils.getDataByEntity(response, closedLoopDatas, serviceName, ClosedLoopD2Services.class);
 148     }
 149
 150     @RequestMapping(value={"/get_ClosedLoopServicesData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 151     public void getClosedLoopServiceDictionaryEntityData(HttpServletResponse response){
 152         DictionaryUtils utils = getDictionaryUtilsInstance();
 153         utils.getData(response, closedLoopDatas, ClosedLoopD2Services.class);
 154     }
 155
 156     @RequestMapping(value={"/get_ClosedLoopSiteDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 157     public void getClosedLoopSiteDictionaryByNameEntityData(HttpServletResponse response){
 158         DictionaryUtils utils = getDictionaryUtilsInstance();
 159         utils.getDataByEntity(response, closedLoopSiteDatas, siteName, ClosedLoopSite.class);
 160     }
 161
 162     @RequestMapping(value={"/get_ClosedLoopSiteData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 163     public void getClosedLoopSiteDictionaryEntityData(HttpServletResponse response){
 164         DictionaryUtils utils = getDictionaryUtilsInstance();
 165         utils.getData(response, closedLoopSiteDatas, ClosedLoopSite.class);
 166     }
 167
 168     @RequestMapping(value={"/cl_dictionary/save_vsclAction"}, method={RequestMethod.POST})
 169     public ModelAndView saveVSCLAction(HttpServletRequest request, HttpServletResponse response)throws IOException{
 170         DictionaryUtils utils = getDictionaryUtilsInstance();
 171         try {
 172             boolean fromAPI = utils.isRequestFromAPI(request);
 173             ObjectMapper mapper = new ObjectMapper();
 174             mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 175             JsonNode root = mapper.readTree(request.getReader());
 176             VSCLAction vSCLAction;
 177             String userId = null;
 178             if (fromAPI) {
 179                 vSCLAction = mapper.readValue(root.get(dictionaryFields).toString(), VSCLAction.class);
 180                 userId = "API";
 181             } else {
 182                 vSCLAction = mapper.readValue(root.get("vsclActionDictionaryData").toString(), VSCLAction.class);
 183                 userId = root.get(userid).textValue();
 184             }
 185             UserInfo userInfo = utils.getUserInfo(userId);
 186
 187             List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(vSCLAction.getVsclaction(), vsclaction, VSCLAction.class);
 188             boolean duplicateflag = false;
 189             if(!duplicateData.isEmpty()){
 190                 VSCLAction data = (VSCLAction) duplicateData.get(0);
 191                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 192                     vSCLAction.setId(data.getId());
 193                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 194                         (request.getParameter(operation) == null && (data.getId() != vSCLAction.getId()))){
 195                     duplicateflag = true;
 196                 }
 197             }
 198             String responseString = null;
 199             if(!duplicateflag){
 200                 vSCLAction.setUserModifiedBy(userInfo);
 201                 if(vSCLAction.getId() == 0){
 202                     vSCLAction.setUserCreatedBy(userInfo);
 203                     commonClassDao.save(vSCLAction);
 204                 }else{
 205                     vSCLAction.setModifiedDate(new Date());
 206                     commonClassDao.update(vSCLAction);
 207                 }
 208                 responseString = mapper.writeValueAsString(commonClassDao.getData(VSCLAction.class));
 209             }else{
 210                 responseString = duplicateResponseString;
 211             }
 212
 213             if(fromAPI){
 214                 return utils.getResultForApi(responseString);
 215             }else{
 216                 utils.setResponseData(response, vsclActionDatas, responseString);
 217             }
 218         }catch(Exception e){
 219             utils.setErrorResponseData(response, e);
 220         }
 221         return null;
 222     }
 223
 224     @RequestMapping(value={"/cl_dictionary/remove_VsclAction"}, method={RequestMethod.POST})
 225     public void removeVSCLAction(HttpServletRequest request, HttpServletResponse response) throws IOException {
 226         DictionaryUtils utils = getDictionaryUtilsInstance();
 227         utils.removeData(request, response, vsclActionDatas, OnapName.class);
 228     }
 229
 230     @RequestMapping(value={"/cl_dictionary/save_vnfType"}, method={RequestMethod.POST})
 231     public ModelAndView saveVnfType(HttpServletRequest request, HttpServletResponse response) throws IOException{
 232         DictionaryUtils utils = getDictionaryUtilsInstance();
 233         try {
 234             boolean fromAPI = utils.isRequestFromAPI(request);
 235             ObjectMapper mapper = new ObjectMapper();
 236             mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 237             JsonNode root = mapper.readTree(request.getReader());
 238             VNFType vNFType;
 239             String userId = null;
 240             if (fromAPI) {
 241                 vNFType = mapper.readValue(root.get(dictionaryFields).toString(), VNFType.class);
 242                 userId = "API";
 243             } else {
 244                 vNFType = mapper.readValue(root.get("vnfTypeDictionaryData").toString(), VNFType.class);
 245                 userId = root.get(userid).textValue();
 246             }
 247             UserInfo userInfo = utils.getUserInfo(userId);
 248
 249             List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(vNFType.getVnftype(), vnftype, VNFType.class);
 250             boolean duplicateflag = false;
 251             if(!duplicateData.isEmpty()){
 252                 VNFType data = (VNFType) duplicateData.get(0);
 253                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 254                     vNFType.setId(data.getId());
 255                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 256                         (request.getParameter(operation) == null && (data.getId() != vNFType.getId()))){
 257                     duplicateflag = true;
 258                 }
 259             }
 260             String responseString = null;
 261             if(!duplicateflag){
 262                 vNFType.setUserModifiedBy(userInfo);
 263                 if(vNFType.getId() == 0){
 264                     vNFType.setUserCreatedBy(userInfo);
 265                     commonClassDao.save(vNFType);
 266                 }else{
 267                     vNFType.setModifiedDate(new Date());
 268                     commonClassDao.update(vNFType);
 269                 }
 270                 responseString = mapper.writeValueAsString(commonClassDao.getData(VNFType.class));
 271             }else{
 272                 responseString = duplicateResponseString;
 273             }
 274
 275             if(fromAPI){
 276                 return utils.getResultForApi(responseString);
 277             }else{
 278                 utils.setResponseData(response, vnfTypeDatas, responseString);
 279             }
 280         }catch(Exception e){
 281             utils.setErrorResponseData(response, e);
 282         }
 283         return null;
 284     }
 285
 286     @RequestMapping(value={"/cl_dictionary/remove_vnfType"}, method={RequestMethod.POST})
 287     public void removeVnfType(HttpServletRequest request, HttpServletResponse response) throws IOException {
 288         DictionaryUtils utils = getDictionaryUtilsInstance();
 289         utils.removeData(request, response, vnfTypeDatas, VNFType.class);
 290     }
 291
 292     @RequestMapping(value={"/cl_dictionary/save_pepOptions"}, method={RequestMethod.POST})
 293     public ModelAndView savePEPOptions(HttpServletRequest request, HttpServletResponse response) throws IOException{
 294         DictionaryUtils utils = getDictionaryUtilsInstance();
 295         try {
 296             boolean fromAPI = utils.isRequestFromAPI(request);
 297             ObjectMapper mapper = new ObjectMapper();
 298             mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 299             JsonNode root = mapper.readTree(request.getReader());
 300             PEPOptions pEPOptions;
 301             GridData gridData;
 302             String userId = null;
 303             if(fromAPI){
 304                 pEPOptions = mapper.readValue(root.get(dictionaryFields).toString(), PEPOptions.class);
 305                 gridData = mapper.readValue(root.get(dictionaryFields).toString(), GridData.class);
 306                 userId = "API";
 307             }else{
 308                 pEPOptions = mapper.readValue(root.get("pepOptionsDictionaryData").toString(), PEPOptions.class);
 309                 gridData = mapper.readValue(root.get("pepOptionsDictionaryData").toString(), GridData.class);
 310                 userId = root.get(userid).textValue();
 311             }
 312             UserInfo userInfo = utils.getUserInfo(userId);
 313
 314             if(!gridData.getAttributes().isEmpty()){
 315                 pEPOptions.setActions(utils.appendKeyValue(gridData.getAttributes(), ":#@", "=#@"));
 316             }
 317
 318             List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(pEPOptions.getPepName(), pepName, PEPOptions.class);
 319             boolean duplicateflag = false;
 320             if(!duplicateData.isEmpty()){
 321                 PEPOptions data = (PEPOptions) duplicateData.get(0);
 322                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 323                     pEPOptions.setId(data.getId());
 324                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 325                         (request.getParameter(operation) == null && (data.getId() != pEPOptions.getId()))){
 326                     duplicateflag = true;
 327                 }
 328             }
 329             String responseString = null;
 330             if(!duplicateflag){
 331                 pEPOptions.setUserModifiedBy(userInfo);
 332                 if(pEPOptions.getId() == 0){
 333                     pEPOptions.setUserCreatedBy(userInfo);
 334                     commonClassDao.save(pEPOptions);
 335                 }else{
 336                     pEPOptions.setModifiedDate(new Date());
 337                     commonClassDao.update(pEPOptions);
 338                 }
 339                 responseString = mapper.writeValueAsString(commonClassDao.getData(PEPOptions.class));
 340             }else{
 341                 responseString = duplicateResponseString;
 342             }
 343
 344             if(fromAPI){
 345                 return utils.getResultForApi(responseString);
 346             }else{
 347                 utils.setResponseData(response, pepOptionDatas, responseString);
 348             }
 349         }catch(Exception e){
 350             utils.setErrorResponseData(response, e);
 351         }
 352         return null;
 353     }
 354
 355     @RequestMapping(value={"/cl_dictionary/remove_pepOptions"}, method={RequestMethod.POST})
 356     public void removePEPOptions(HttpServletRequest request, HttpServletResponse response) throws IOException {
 357         DictionaryUtils utils = getDictionaryUtilsInstance();
 358         utils.removeData(request, response, pepOptionDatas, VNFType.class);
 359     }
 360
 361     @RequestMapping(value={"/cl_dictionary/save_service"}, method={RequestMethod.POST})
 362     public ModelAndView saveServiceType(HttpServletRequest request, HttpServletResponse response) throws IOException{
 363         DictionaryUtils utils = getDictionaryUtilsInstance();
 364         try {
 365             boolean fromAPI = utils.isRequestFromAPI(request);
 366             ObjectMapper mapper = new ObjectMapper();
 367             mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 368             JsonNode root = mapper.readTree(request.getReader());
 369             ClosedLoopD2Services serviceData;
 370             String userId = null;
 371             if(fromAPI){
 372                 serviceData = mapper.readValue(root.get(dictionaryFields).toString(), ClosedLoopD2Services.class);
 373                 userId = "API";
 374             } else {
 375                 serviceData = mapper.readValue(root.get("closedLoopServiceDictionaryData").toString(), ClosedLoopD2Services.class);
 376                 userId = root.get(userid).textValue();
 377             }
 378             UserInfo userInfo = utils.getUserInfo(userId);
 379
 380             List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(serviceData.getServiceName(), serviceName, ClosedLoopD2Services.class);
 381             boolean duplicateflag = false;
 382             if(!duplicateData.isEmpty()){
 383                 ClosedLoopD2Services data = (ClosedLoopD2Services) duplicateData.get(0);
 384                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 385                     serviceData.setId(data.getId());
 386                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 387                         (request.getParameter(operation) == null && (data.getId() != serviceData.getId()))){
 388                     duplicateflag = true;
 389                 }
 390             }
 391             String responseString = null;
 392             if(!duplicateflag){
 393                 serviceData.setUserModifiedBy(userInfo);
 394                 if(serviceData.getId() == 0){
 395                     serviceData.setUserCreatedBy(userInfo);
 396                     commonClassDao.save(serviceData);
 397                 }else{
 398                     serviceData.setModifiedDate(new Date());
 399                     commonClassDao.update(serviceData);
 400                 }
 401                 responseString = mapper.writeValueAsString(commonClassDao.getData(ClosedLoopD2Services.class));
 402             }else{
 403                 responseString = duplicateResponseString;
 404             }
 405             if(fromAPI){
 406                 return utils.getResultForApi(responseString);
 407             }else{
 408                 utils.setResponseData(response, closedLoopDatas, responseString);
 409             }
 410         }catch(Exception e){
 411             utils.setErrorResponseData(response, e);
 412         }
 413         return null;
 414     }
 415
 416     @RequestMapping(value={"/cl_dictionary/remove_Service"}, method={RequestMethod.POST})
 417     public void removeServiceType(HttpServletRequest request, HttpServletResponse response) throws IOException {
 418         DictionaryUtils utils = getDictionaryUtilsInstance();
 419         utils.removeData(request, response, closedLoopDatas, VNFType.class);
 420     }
 421
 422     @RequestMapping(value={"/cl_dictionary/save_siteName"}, method={RequestMethod.POST})
 423     public ModelAndView saveSiteType(HttpServletRequest request, HttpServletResponse response) throws IOException{
 424         DictionaryUtils utils = getDictionaryUtilsInstance();
 425         try {
 426             boolean fromAPI = utils.isRequestFromAPI(request);
 427             ObjectMapper mapper = new ObjectMapper();
 428             mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 429             JsonNode root = mapper.readTree(request.getReader());
 430             ClosedLoopSite siteData;
 431             String userId = null;
 432             if(fromAPI){
 433                 siteData = mapper.readValue(root.get(dictionaryFields).toString(), ClosedLoopSite.class);
 434                 userId = "API";
 435             }else{
 436                 siteData = mapper.readValue(root.get("closedLoopSiteDictionaryData").toString(), ClosedLoopSite.class);
 437                 userId = root.get(userid).textValue();
 438             }
 439             UserInfo userInfo = utils.getUserInfo(userId);
 440
 441             List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(siteData.getSiteName(), siteName, ClosedLoopSite.class);
 442             boolean duplicateflag = false;
 443             if(!duplicateData.isEmpty()){
 444                 ClosedLoopSite data = (ClosedLoopSite) duplicateData.get(0);
 445                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 446                     siteData.setId(data.getId());
 447                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 448                         (request.getParameter(operation) == null && (data.getId() != siteData.getId()))){
 449                     duplicateflag = true;
 450                 }
 451             }
 452             String responseString = null;
 453             if(!duplicateflag){
 454                 siteData.setUserModifiedBy(userInfo);
 455                 if(siteData.getId() == 0){
 456                     siteData.setUserCreatedBy(userInfo);
 457                     commonClassDao.save(siteData);
 458                 }else{
 459                     siteData.setModifiedDate(new Date());
 460                     commonClassDao.update(siteData);
 461                 }
 462                 responseString = mapper.writeValueAsString(commonClassDao.getData(ClosedLoopSite.class));
 463             }else{
 464                 responseString = duplicateResponseString;
 465             }
 466             if(fromAPI){
 467                 return utils.getResultForApi(responseString);
 468             }else{
 469                 utils.setResponseData(response, closedLoopSiteDatas, responseString);
 470             }
 471         }catch (Exception e){
 472             utils.setErrorResponseData(response, e);
 473         }
 474         return null;
 475     }
 476
 477     @RequestMapping(value={"/cl_dictionary/remove_site"}, method={RequestMethod.POST})
 478     public void removeSiteType(HttpServletRequest request, HttpServletResponse response) throws IOException {
 479         DictionaryUtils utils = getDictionaryUtilsInstance();
 480         utils.removeData(request, response, closedLoopSiteDatas, VNFType.class);
 481     }
 482
 483     @RequestMapping(value={"/cl_dictionary/save_varbind"}, method={RequestMethod.POST})
 484     public ModelAndView saveVarbind(HttpServletRequest request, HttpServletResponse response) throws IOException{
 485         DictionaryUtils utils = getDictionaryUtilsInstance();
 486         try {
 487             boolean fromAPI = utils.isRequestFromAPI(request);
 488             ObjectMapper mapper = new ObjectMapper();
 489             mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 490             JsonNode root = mapper.readTree(request.getReader());
 491             VarbindDictionary varbindDictionary;
 492             String userId = null;
 493             if(fromAPI){
 494                 varbindDictionary = mapper.readValue(root.get(dictionaryFields).toString(), VarbindDictionary.class);
 495                 userId = "API";
 496             }else{
 497                 varbindDictionary = mapper.readValue(root.get("varbindDictionaryData").toString(), VarbindDictionary.class);
 498                 userId = root.get(userid).textValue();
 499             }
 500             UserInfo userInfo = utils.getUserInfo(userId);
 501
 502             List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(varbindDictionary.getVarbindName(), varbindName, VarbindDictionary.class);
 503             boolean duplicateflag = false;
 504             if(!duplicateData.isEmpty()){
 505                 VarbindDictionary data = (VarbindDictionary) duplicateData.get(0);
 506                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 507                     varbindDictionary.setId(data.getId());
 508                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 509                         (request.getParameter(operation) == null && (data.getId() != varbindDictionary.getId()))){
 510                     duplicateflag = true;
 511                 }
 512             }
 513
 514             String responseString = null;
 515             if(!duplicateflag){
 516                 varbindDictionary.setUserModifiedBy(userInfo);
 517                 if(varbindDictionary.getId() == 0){
 518                     varbindDictionary.setUserCreatedBy(userInfo);
 519                     commonClassDao.save(varbindDictionary);
 520                 }else{
 521                     varbindDictionary.setModifiedDate(new Date());
 522                     commonClassDao.update(varbindDictionary);
 523                 }
 524                 responseString = mapper.writeValueAsString(commonClassDao.getData(VarbindDictionary.class));
 525             }else{
 526                 responseString = duplicateResponseString;
 527             }
 528             if(fromAPI){
 529                 return utils.getResultForApi(responseString);
 530             }else{
 531                 utils.setResponseData(response, varbindDatas, responseString);
 532             }
 533         }catch (Exception e){
 534             utils.setErrorResponseData(response, e);
 535         }
 536         return null;
 537     }
 538
 539     @RequestMapping(value={"/cl_dictionary/remove_varbindDict"}, method={RequestMethod.POST})
 540     public void removeVarbind(HttpServletRequest request, HttpServletResponse response) throws IOException{
 541         DictionaryUtils utils = getDictionaryUtilsInstance();
 542         utils.removeData(request, response, varbindDatas, VNFType.class);
 543     }
 544 }