ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/FirewallDictionaryController.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.net.UnknownHostException;
  26 import java.util.Date;
  27 import java.util.List;
  28
  29 import javax.servlet.http.HttpServletRequest;
  30 import javax.servlet.http.HttpServletResponse;
  31
  32 import org.jboss.netty.handler.ipfilter.CIDR;
  33 import org.json.JSONObject;
  34 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  35 import org.onap.policy.common.logging.flexlogger.Logger;
  36 import org.onap.policy.pap.xacml.rest.adapters.GridData;
  37 import org.onap.policy.pap.xacml.rest.util.DictionaryUtils;
  38 import org.onap.policy.rest.dao.CommonClassDao;
  39 import org.onap.policy.rest.jpa.ActionList;
  40 import org.onap.policy.rest.jpa.AddressGroup;
  41 import org.onap.policy.rest.jpa.FWTag;
  42 import org.onap.policy.rest.jpa.FWTagPicker;
  43 import org.onap.policy.rest.jpa.FirewallDictionaryList;
  44 import org.onap.policy.rest.jpa.GroupServiceList;
  45 import org.onap.policy.rest.jpa.PortList;
  46 import org.onap.policy.rest.jpa.PrefixList;
  47 import org.onap.policy.rest.jpa.ProtocolList;
  48 import org.onap.policy.rest.jpa.SecurityZone;
  49 import org.onap.policy.rest.jpa.ServiceList;
  50 import org.onap.policy.rest.jpa.TermList;
  51 import org.onap.policy.rest.jpa.UserInfo;
  52 import org.onap.policy.rest.jpa.Zone;
  53 import org.springframework.beans.factory.annotation.Autowired;
  54 import org.springframework.http.MediaType;
  55 import org.springframework.stereotype.Controller;
  56 import org.springframework.web.bind.annotation.RequestMapping;
  57 import org.springframework.web.bind.annotation.RequestMethod;
  58 import org.springframework.web.servlet.ModelAndView;
  59
  60 import com.fasterxml.jackson.databind.DeserializationFeature;
  61 import com.fasterxml.jackson.databind.JsonNode;
  62 import com.fasterxml.jackson.databind.ObjectMapper;
  63
  64
  65 @Controller
  66 public class FirewallDictionaryController {
  67
  68         private static final Logger LOGGER  = FlexLogger.getLogger(FirewallDictionaryController.class);
  69
  70         private static CommonClassDao commonClassDao;
  71         private static String prefixListName = "prefixListName";
  72         private static String successMessage = "success";
  73         private static String operation = "operation";
  74         private static String errorMsg  = "error";
  75         private static String dictionaryFields ="dictionaryFields";
  76         private static String duplicateResponseString = "Duplicate";
  77         private static String utf8 = "UTF-8";
  78         private static String applicationJsonContentType = "application / json";
  79         private static String protocolName = "protocolName";
  80         private static String groupNameStart = "Group_";
  81         private static String option = "option";
  82         private static String zoneName =  "zoneName";
  83         private static String serviceName = "serviceName";
  84         private static String termName = "termName";
  85         private static String userid = "userid";
  86         private static String tagPickerName = "tagPickerName";
  87         private static String pfListDatas = "prefixListDictionaryDatas";
  88         private static String portListDatas = "portListDictionaryDatas";
  89         private static String protocolListDatas = "protocolListDictionaryDatas";
  90         private static String addressGroupDatas = "addressGroupDictionaryDatas";
  91         private static String actionListDatas = "actionListDictionaryDatas";
  92         private static String serviceGroupDatas = "serviceGroupDictionaryDatas";
  93         private static String securityZoneDatas = "securityZoneDictionaryDatas";
  94         private static String serviceListDatas = "serviceListDictionaryDatas";
  95         private static String zoneDatas = "zoneDictionaryDatas";
  96         private static String termListDictDatas = "termListDictionaryDatas";
  97         private static String fwDictListDatas = "fwDictListDictionaryDatas";
  98         private static String fwTagPickerDatas = "fwTagPickerDictionaryDatas";
  99         private static String fwTagDatas = "fwTagDictionaryDatas";
 100
 101
 102         @Autowired
 103         public FirewallDictionaryController(CommonClassDao commonClassDao){
 104                 FirewallDictionaryController.commonClassDao = commonClassDao;
 105         }
 106
 107         public static void setCommonClassDao(CommonClassDao clDao){
 108             commonClassDao = clDao;
 109         }
 110
 111         public FirewallDictionaryController(){
 112                 super();
 113         }
 114
 115         private DictionaryUtils getDictionaryUtilsInstance(){
 116                 return DictionaryUtils.dictionaryUtils != null ? DictionaryUtils.getDictionaryUtils() : new DictionaryUtils();
 117         }
 118
 119         @RequestMapping(value={"/get_PrefixListDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 120         public void getPrefixListDictionaryEntityDataByName(HttpServletResponse response){
 121                 DictionaryUtils utils = getDictionaryUtilsInstance();
 122                 utils.getDataByEntity(response, pfListDatas, prefixListName, PrefixList.class);
 123         }
 124
 125         @RequestMapping(value={"/get_PrefixListData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 126         public void getPrefixListDictionaryEntityData(HttpServletResponse response){
 127                 DictionaryUtils utils = getDictionaryUtilsInstance();
 128                 utils.getData(response, pfListDatas, PrefixList.class);
 129         }
 130
 131         @RequestMapping(value={"/fw_dictionary/save_prefixList"}, method={RequestMethod.POST})
 132         public ModelAndView savePrefixListDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 133                 DictionaryUtils utils = getDictionaryUtilsInstance();
 134                 try {
 135                         boolean fromAPI = utils.isRequestFromAPI(request);
 136                         ObjectMapper mapper = new ObjectMapper();
 137                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 138                         JsonNode root = mapper.readTree(request.getReader());
 139                         PrefixList prefixList;
 140                         if (fromAPI) {
 141                                 prefixList = mapper.readValue(root.get(dictionaryFields).toString(), PrefixList.class);
 142                         } else {
 143                                 prefixList = mapper.readValue(root.get("prefixListDictionaryData").toString(), PrefixList.class);
 144                         }
 145
 146                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(prefixList.getPrefixListName(), prefixListName, PrefixList.class);
 147                         boolean duplicateflag = false;
 148                         if(!duplicateData.isEmpty()){
 149                                 PrefixList data = (PrefixList) duplicateData.get(0);
 150                                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 151                                         prefixList.setId(data.getId());
 152                                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 153                                                 (request.getParameter(operation) == null && (data.getId() != prefixList.getId()))){
 154                                         duplicateflag = true;
 155                                 }
 156                         }
 157                         String responseString = null;
 158                         if(!duplicateflag){
 159                                 if(prefixList.getId() == 0){
 160                                         commonClassDao.save(prefixList);
 161                                 }else{
 162                                         commonClassDao.update(prefixList);
 163                                 }
 164                                 responseString = mapper.writeValueAsString(commonClassDao.getData(PrefixList.class));
 165                         }else{
 166                                 responseString = duplicateResponseString;
 167                         }
 168                         if(fromAPI){
 169                                 return utils.getResultForApi(responseString);
 170                         }else{
 171                                 utils.setResponseData(response, pfListDatas, responseString);
 172                         }
 173                 }catch (Exception e){
 174                         utils.setErrorResponseData(response, e);
 175                 }
 176                 return null;
 177         }
 178
 179         @RequestMapping(value={"/fw_dictionary/remove_PrefixList"}, method={RequestMethod.POST})
 180         public void removePrefixListDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 181                 DictionaryUtils utils = getDictionaryUtilsInstance();
 182                 utils.removeData(request, response, pfListDatas, PrefixList.class);
 183         }
 184
 185         @RequestMapping(value={"/fw_dictionary/validate_prefixList"}, method={RequestMethod.POST})
 186         public void validatePrefixListDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 187                 DictionaryUtils utils = getDictionaryUtilsInstance();
 188                 try {
 189                         ObjectMapper mapper = new ObjectMapper();
 190                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 191                         JsonNode root = mapper.readTree(request.getReader());
 192                         PrefixList prefixList = mapper.readValue(root.get("prefixListDictionaryData").toString(), PrefixList.class);
 193                         String responseValidation = successMessage;
 194                         try{
 195                                 CIDR.newCIDR(prefixList.getPrefixListValue());
 196                         }catch(UnknownHostException e){
 197                                 LOGGER.error(e);
 198                                 responseValidation = errorMsg;
 199                         }
 200                         response.setCharacterEncoding(utf8);
 201                         response.setContentType(applicationJsonContentType);
 202                         request.setCharacterEncoding(utf8);
 203
 204                         PrintWriter out = response.getWriter();
 205                         JSONObject j = new JSONObject("{result: " + responseValidation + "}");
 206                         out.write(j.toString());
 207                 }
 208                 catch (Exception e){
 209                         utils.setErrorResponseData(response, e);
 210                 }
 211         }
 212
 213         @RequestMapping(value={"/get_PortListData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 214         public void getPortListDictionaryEntityData(HttpServletResponse response){
 215                 DictionaryUtils utils = getDictionaryUtilsInstance();
 216                 utils.getData(response, portListDatas, PortList.class);
 217         }
 218
 219         @RequestMapping(value={"/fw_dictionary/save_portName"}, method={RequestMethod.POST})
 220         public ModelAndView savePortListDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 221                 DictionaryUtils utils = getDictionaryUtilsInstance();
 222                 try {
 223                         boolean fromAPI = utils.isRequestFromAPI(request);
 224                         ObjectMapper mapper = new ObjectMapper();
 225                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 226                         JsonNode root = mapper.readTree(request.getReader());
 227                         PortList portList;
 228                         if(fromAPI){
 229                                 portList = mapper.readValue(root.get(dictionaryFields).toString(), PortList.class);
 230                         }else{
 231                                 portList = mapper.readValue(root.get("portListDictionaryData").toString(), PortList.class);
 232                         }
 233                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(portList.getPortName(), "portName", PortList.class);
 234                         boolean duplicateflag = false;
 235                         if(!duplicateData.isEmpty()){
 236                                 PortList data = (PortList) duplicateData.get(0);
 237                                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 238                                         portList.setId(data.getId());
 239                                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 240                                                 (request.getParameter(operation) == null && (data.getId() != portList.getId()))){
 241                                         duplicateflag = true;
 242                                 }
 243                         }
 244                         String responseString = null;
 245                         if(!duplicateflag){
 246                                 if(portList.getId() == 0){
 247                                         commonClassDao.save(portList);
 248                                 }else{
 249                                         commonClassDao.update(portList);
 250                                 }
 251                                 responseString = mapper.writeValueAsString(commonClassDao.getData(PortList.class));
 252                         }else{
 253                                 responseString = duplicateResponseString;
 254                         }
 255                         if(fromAPI){
 256                                 return utils.getResultForApi(responseString);
 257                         }else{
 258                                 utils.setResponseData(response, portListDatas, responseString);
 259                         }
 260                 }catch (Exception e){
 261                         utils.setErrorResponseData(response, e);
 262                 }
 263                 return null;
 264         }
 265
 266         @RequestMapping(value={"/fw_dictionary/remove_PortList"}, method={RequestMethod.POST})
 267         public void removePortListDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 268                 DictionaryUtils utils = getDictionaryUtilsInstance();
 269                 utils.removeData(request, response, portListDatas, PortList.class);
 270         }
 271
 272         @RequestMapping(value={"/get_ProtocolListData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 273         public void getProtocolListDictionaryEntityData(HttpServletResponse response){
 274                 DictionaryUtils utils = getDictionaryUtilsInstance();
 275                 utils.getData(response, protocolListDatas, ProtocolList.class);
 276         }
 277
 278         @RequestMapping(value={"/get_ProtocolListDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 279         public void getProtocolListDictionaryEntityDataByName(HttpServletResponse response){
 280                 DictionaryUtils utils = getDictionaryUtilsInstance();
 281                 utils.getDataByEntity(response, protocolListDatas, protocolName, ProtocolList.class);
 282         }
 283
 284         @RequestMapping(value={"/fw_dictionary/save_protocolList"}, method={RequestMethod.POST})
 285         public ModelAndView saveProtocolListDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 286                 DictionaryUtils utils = getDictionaryUtilsInstance();
 287                 try {
 288                         boolean fromAPI = utils.isRequestFromAPI(request);
 289                         ObjectMapper mapper = new ObjectMapper();
 290                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 291                         JsonNode root = mapper.readTree(request.getReader());
 292                         ProtocolList protocolList;
 293                         if(fromAPI){
 294                                 protocolList = mapper.readValue(root.get(dictionaryFields).toString(), ProtocolList.class);
 295                         }else{
 296                                 protocolList = mapper.readValue(root.get("protocolListDictionaryData").toString(), ProtocolList.class);
 297                         }
 298                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(protocolList.getProtocolName(), protocolName, ProtocolList.class);
 299                         boolean duplicateflag = false;
 300                         if(!duplicateData.isEmpty()){
 301                                 ProtocolList data = (ProtocolList) duplicateData.get(0);
 302                                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 303                                         protocolList.setId(data.getId());
 304                                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 305                                                 (request.getParameter(operation) == null && (data.getId() != protocolList.getId()))){
 306                                         duplicateflag = true;
 307                                 }
 308                         }
 309                         String responseString = null;
 310                         if(!duplicateflag){
 311                                 if(protocolList.getId() == 0){
 312                                         commonClassDao.save(protocolList);
 313                                 }else{
 314                                         commonClassDao.update(protocolList);
 315                                 }
 316                                 responseString = mapper.writeValueAsString(commonClassDao.getData(ProtocolList.class));
 317                         }else{
 318                                 responseString = duplicateResponseString;
 319                         }
 320                         if(fromAPI){
 321                                 return utils.getResultForApi(responseString);
 322                         }else{
 323                                 utils.setResponseData(response, protocolListDatas, responseString);
 324                         }
 325                 }catch (Exception e){
 326                         utils.setErrorResponseData(response, e);
 327                 }
 328                 return null;
 329         }
 330
 331         @RequestMapping(value={"/fw_dictionary/remove_protocol"}, method={RequestMethod.POST})
 332         public void removeProtocolListDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 333                 DictionaryUtils utils = getDictionaryUtilsInstance();
 334                 utils.removeData(request, response, protocolListDatas, ProtocolList.class);
 335         }
 336
 337         @RequestMapping(value={"/get_AddressGroupDictionaryDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 338         public void getAddressGroupDictionaryEntityDataByName(HttpServletResponse response){
 339                 DictionaryUtils utils = getDictionaryUtilsInstance();
 340                 utils.getDataByEntity(response, addressGroupDatas, "name", AddressGroup.class);
 341         }
 342
 343         @RequestMapping(value={"/get_AddressGroupData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 344         public void getAddressGroupDictionaryEntityData(HttpServletResponse response){
 345                 DictionaryUtils utils = getDictionaryUtilsInstance();
 346                 utils.getData(response, addressGroupDatas, AddressGroup.class);
 347         }
 348
 349         @RequestMapping(value={"/fw_dictionary/save_addressGroup"}, method={RequestMethod.POST})
 350         public ModelAndView saveAddressGroupDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 351                 DictionaryUtils utils = getDictionaryUtilsInstance();
 352                 try {
 353                         boolean fromAPI = utils.isRequestFromAPI(request);
 354                         ObjectMapper mapper = new ObjectMapper();
 355                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 356                         JsonNode root = mapper.readTree(request.getReader());
 357                         AddressGroup addressGroup;
 358                         GridData gridData;
 359                         if(fromAPI){
 360                                 addressGroup = mapper.readValue(root.get(dictionaryFields).toString(), AddressGroup.class);
 361                                 gridData = mapper.readValue(root.get(dictionaryFields).toString(), GridData.class);
 362                         }else{
 363                                 addressGroup = mapper.readValue(root.get("addressGroupDictionaryData").toString(), AddressGroup.class);
 364                                 gridData = mapper.readValue(root.get("addressGroupDictionaryData").toString(), GridData.class);
 365                         }
 366                         if(!addressGroup.getGroupName().startsWith(groupNameStart)){
 367                                 String groupName = groupNameStart+addressGroup.getGroupName();
 368                                 addressGroup.setGroupName(groupName);
 369                         }
 370                         addressGroup.setServiceList(utils.appendKey(gridData.getAttributes(), option, ","));
 371                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(addressGroup.getGroupName(), "name", AddressGroup.class);
 372                         boolean duplicateflag = false;
 373                         if(!duplicateData.isEmpty()){
 374                                 AddressGroup data = (AddressGroup) duplicateData.get(0);
 375                                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 376                                         addressGroup.setId(data.getId());
 377                                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 378                                                 (request.getParameter(operation) == null && (data.getId() != addressGroup.getId()))){
 379                                         duplicateflag = true;
 380                                 }
 381                         }
 382                         String responseString = null;
 383                         if(!duplicateflag){
 384                                 if(addressGroup.getId() == 0){
 385                                         commonClassDao.save(addressGroup);
 386                                 }else{
 387                                         commonClassDao.update(addressGroup);
 388                                 }
 389                                 responseString = mapper.writeValueAsString(commonClassDao.getData(AddressGroup.class));
 390                         }else{
 391                                 responseString = duplicateResponseString;
 392                         }
 393                         if(fromAPI){
 394                                 return utils.getResultForApi(responseString);
 395                         }else{
 396                                 utils.setResponseData(response, addressGroupDatas, responseString);
 397                         }
 398                 }catch (Exception e){
 399                         utils.setErrorResponseData(response, e);
 400                 }
 401                 return null;
 402         }
 403
 404         @RequestMapping(value={"/fw_dictionary/remove_AddressGroup"}, method={RequestMethod.POST})
 405         public void removeAddressGroupDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 406                 DictionaryUtils utils = getDictionaryUtilsInstance();
 407                 utils.removeData(request, response, addressGroupDatas, AddressGroup.class);
 408         }
 409
 410         @RequestMapping(value={"/get_ActionListDictionaryDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 411         public void getActionListDictionaryEntityDataByName(HttpServletResponse response){
 412                 DictionaryUtils utils = getDictionaryUtilsInstance();
 413                 utils.getDataByEntity(response, actionListDatas, "actionName", ActionList.class);
 414         }
 415
 416         @RequestMapping(value={"/get_ActionListData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 417         public void getActionListDictionaryEntityData(HttpServletResponse response){
 418                 DictionaryUtils utils = getDictionaryUtilsInstance();
 419                 utils.getData(response, actionListDatas, ActionList.class);
 420         }
 421
 422         @RequestMapping(value={"/fw_dictionary/save_ActionList"}, method={RequestMethod.POST})
 423         public ModelAndView saveActionListDictionary(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                         ActionList actionList;
 431                         if (fromAPI) {
 432                                 actionList = mapper.readValue(root.get(dictionaryFields).toString(), ActionList.class);
 433                         } else {
 434                                 actionList = mapper.readValue(root.get("actionListDictionaryData").toString(), ActionList.class);
 435                         }
 436                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(actionList.getActionName(), "actionName", ActionList.class);
 437                         boolean duplicateflag = false;
 438                         if(!duplicateData.isEmpty()){
 439                                 ActionList data = (ActionList) duplicateData.get(0);
 440                                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 441                                         actionList.setId(data.getId());
 442                                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 443                                                 (request.getParameter(operation) == null && (data.getId() != actionList.getId()))){
 444                                         duplicateflag = true;
 445                                 }
 446                         }
 447                         String responseString = null;
 448                         if(!duplicateflag){
 449                                 if(actionList.getId() == 0){
 450                                         commonClassDao.save(actionList);
 451                                 }else{
 452                                         commonClassDao.update(actionList);
 453                                 }
 454                                 responseString = mapper.writeValueAsString(commonClassDao.getData(ActionList.class));
 455                         }else{
 456                                 responseString = duplicateResponseString;
 457                         }
 458                         if(fromAPI){
 459                                 return utils.getResultForApi(responseString);
 460                         }else{
 461                                 utils.setResponseData(response, actionListDatas, responseString);
 462                         }
 463                 }catch (Exception e){
 464                         utils.setErrorResponseData(response, e);
 465                 }
 466                 return null;
 467         }
 468
 469         @RequestMapping(value={"/fw_dictionary/remove_ActionList"}, method={RequestMethod.POST})
 470         public void removeActionListDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 471                 DictionaryUtils utils = getDictionaryUtilsInstance();
 472                 utils.removeData(request, response, actionListDatas, ActionList.class);
 473         }
 474
 475         @RequestMapping(value={"/get_ServiceGroupData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 476         public void getServiceGroupDictionaryEntityData(HttpServletResponse response){
 477                 DictionaryUtils utils = getDictionaryUtilsInstance();
 478                 utils.getData(response, serviceGroupDatas, GroupServiceList.class);
 479         }
 480
 481         @RequestMapping(value={"/get_ServiceGroupDictionaryDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 482         public void getServiceGroupDictionaryEntityDataByName(HttpServletResponse response){
 483                 DictionaryUtils utils = getDictionaryUtilsInstance();
 484                 utils.getDataByEntity(response, serviceGroupDatas, "name", GroupServiceList.class);
 485         }
 486
 487         @RequestMapping(value={"/fw_dictionary/save_serviceGroup"}, method={RequestMethod.POST})
 488         public ModelAndView saveServiceGroupDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 489                 DictionaryUtils utils = getDictionaryUtilsInstance();
 490                 try {
 491                         boolean fromAPI = utils.isRequestFromAPI(request);
 492                         ObjectMapper mapper = new ObjectMapper();
 493                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 494                         JsonNode root = mapper.readTree(request.getReader());
 495                         GroupServiceList groupServiceList;
 496                         GridData gridData;
 497                         if(fromAPI){
 498                                 groupServiceList = mapper.readValue(root.get(dictionaryFields).toString(), GroupServiceList.class);
 499                                 gridData = mapper.readValue(root.get(dictionaryFields).toString(), GridData.class);
 500                         }else{
 501                                 groupServiceList = mapper.readValue(root.get("serviceGroupDictionaryData").toString(), GroupServiceList.class);
 502                                 gridData = mapper.readValue(root.get("serviceGroupDictionaryData").toString(), GridData.class);
 503                         }
 504                         if(!groupServiceList.getGroupName().startsWith(groupNameStart)){
 505                                 String groupName = groupNameStart+groupServiceList.getGroupName();
 506                                 groupServiceList.setGroupName(groupName);
 507                         }
 508                         groupServiceList.setServiceList(utils.appendKey(gridData.getAttributes(), option, ","));
 509                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(groupServiceList.getGroupName(), "name", GroupServiceList.class);
 510                         boolean duplicateflag = false;
 511                         if(!duplicateData.isEmpty()){
 512                                 GroupServiceList data = (GroupServiceList) duplicateData.get(0);
 513                                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 514                                         groupServiceList.setId(data.getId());
 515                                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 516                                                 (request.getParameter(operation) == null && (data.getId() != groupServiceList.getId()))){
 517                                         duplicateflag = true;
 518                                 }
 519                         }
 520                         String responseString = null;
 521                         if(!duplicateflag){
 522                                 if(groupServiceList.getId() == 0){
 523                                         commonClassDao.save(groupServiceList);
 524                                 }else{
 525                                         commonClassDao.update(groupServiceList);
 526                                 }
 527                                 responseString = mapper.writeValueAsString(commonClassDao.getData(GroupServiceList.class));
 528                         }else{
 529                                 responseString = duplicateResponseString;
 530                         }
 531                         if(fromAPI){
 532                                 return utils.getResultForApi(responseString);
 533                         }else{
 534                                 utils.setResponseData(response, serviceGroupDatas, responseString);
 535                         }
 536                 }catch (Exception e){
 537                         utils.setErrorResponseData(response, e);
 538                 }
 539                 return null;
 540         }
 541
 542         @RequestMapping(value={"/fw_dictionary/remove_serviceGroup"}, method={RequestMethod.POST})
 543         public void removeServiceGroupDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 544                 DictionaryUtils utils = getDictionaryUtilsInstance();
 545                 utils.removeData(request, response, serviceGroupDatas, GroupServiceList.class);
 546         }
 547
 548         @RequestMapping(value={"/get_SecurityZoneDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 549         public void getSecurityZoneDictionaryEntityDataByName(HttpServletResponse response){
 550                 DictionaryUtils utils = getDictionaryUtilsInstance();
 551                 utils.getDataByEntity(response, securityZoneDatas, zoneName, SecurityZone.class);
 552         }
 553
 554         @RequestMapping(value={"/get_SecurityZoneData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 555         public void getSecurityZoneDictionaryEntityData(HttpServletResponse response){
 556                 DictionaryUtils utils = getDictionaryUtilsInstance();
 557                 utils.getData(response, securityZoneDatas, SecurityZone.class);
 558         }
 559
 560         @RequestMapping(value={"/fw_dictionary/save_securityZone"}, method={RequestMethod.POST})
 561         public ModelAndView saveSecurityZoneDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 562                 DictionaryUtils utils = getDictionaryUtilsInstance();
 563                 try {
 564                         boolean fromAPI = utils.isRequestFromAPI(request);
 565                         ObjectMapper mapper = new ObjectMapper();
 566                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 567                         JsonNode root = mapper.readTree(request.getReader());
 568                         SecurityZone securityZone;
 569                         if(fromAPI){
 570                                 securityZone = mapper.readValue(root.get(dictionaryFields).toString(), SecurityZone.class);
 571                         }else{
 572                                 securityZone = mapper.readValue(root.get("securityZoneDictionaryData").toString(), SecurityZone.class);
 573                         }
 574                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(securityZone.getZoneName(), zoneName, SecurityZone.class);
 575                         boolean duplicateflag = false;
 576                         if(!duplicateData.isEmpty()){
 577                                 SecurityZone data = (SecurityZone) duplicateData.get(0);
 578                                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 579                                         securityZone.setId(data.getId());
 580                                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 581                                                 (request.getParameter(operation) == null && (data.getId() != securityZone.getId()))){
 582                                         duplicateflag = true;
 583                                 }
 584                         }
 585                         String responseString = null;
 586                         if(!duplicateflag){
 587                                 if(securityZone.getId() == 0){
 588                                         commonClassDao.save(securityZone);
 589                                 }else{
 590                                         commonClassDao.update(securityZone);
 591                                 }
 592                                 responseString = mapper.writeValueAsString(commonClassDao.getData(SecurityZone.class));
 593                         }else{
 594                                 responseString = duplicateResponseString;
 595                         }
 596                         if(fromAPI){
 597                                 return utils.getResultForApi(responseString);
 598                         }else{
 599                                 utils.setResponseData(response, securityZoneDatas, responseString);
 600                         }
 601                 }catch (Exception e){
 602                         utils.setErrorResponseData(response, e);
 603                 }
 604                 return null;
 605         }
 606
 607         @RequestMapping(value={"/fw_dictionary/remove_securityZone"}, method={RequestMethod.POST})
 608         public void removeSecurityZoneDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException {
 609                 DictionaryUtils utils = getDictionaryUtilsInstance();
 610                 utils.removeData(request, response, securityZoneDatas, SecurityZone.class);
 611         }
 612
 613
 614         @RequestMapping(value={"/get_ServiceListData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 615         public void getServiceListDictionaryEntityData(HttpServletResponse response){
 616                 DictionaryUtils utils = getDictionaryUtilsInstance();
 617                 utils.getData(response, serviceListDatas, ServiceList.class);
 618         }
 619
 620         @RequestMapping(value={"/get_ServiceListDictionaryDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 621         public void getServiceListDictionaryEntityDataByName(HttpServletResponse response){
 622                 DictionaryUtils utils = getDictionaryUtilsInstance();
 623                 utils.getDataByEntity(response, serviceListDatas, serviceName, ServiceList.class);
 624         }
 625
 626         @RequestMapping(value={"/fw_dictionary/save_serviceList"}, method={RequestMethod.POST})
 627         public ModelAndView saveServiceListDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 628                 DictionaryUtils utils = getDictionaryUtilsInstance();
 629                 try {
 630                         boolean fromAPI = utils.isRequestFromAPI(request);
 631                         ObjectMapper mapper = new ObjectMapper();
 632                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 633                         JsonNode root = mapper.readTree(request.getReader());
 634                         ServiceList serviceList;
 635                         GridData serviceListGridData;
 636                         if(fromAPI){
 637                                 serviceList = mapper.readValue(root.get(dictionaryFields).toString(), ServiceList.class);
 638                                 serviceListGridData = mapper.readValue(root.get(dictionaryFields).toString(), GridData.class);
 639                         }else{
 640                                 serviceList = mapper.readValue(root.get("serviceListDictionaryData").toString(), ServiceList.class);
 641                                 serviceListGridData = mapper.readValue(root.get("serviceListDictionaryData").toString(), GridData.class);
 642                         }
 643                         serviceList.setServiceTransProtocol(utils.appendKey(serviceListGridData.getTransportProtocols(), option, ","));
 644                         serviceList.setServiceAppProtocol(utils.appendKey(serviceListGridData.getAppProtocols(), option, ","));
 645                         serviceList.setServiceType("SERVICE");
 646                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(serviceList.getServiceName(), serviceName, ServiceList.class);
 647                         boolean duplicateflag = false;
 648                         if(!duplicateData.isEmpty()){
 649                                 ServiceList data = (ServiceList) duplicateData.get(0);
 650                                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 651                                         serviceList.setId(data.getId());
 652                                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 653                                                 (request.getParameter(operation) == null && (data.getId() != serviceList.getId()))){
 654                                         duplicateflag = true;
 655                                 }
 656                         }
 657                         String responseString = null;
 658                         if(!duplicateflag){
 659                                 if(serviceList.getId() == 0){
 660                                         commonClassDao.save(serviceList);
 661                                 }else{
 662                                         commonClassDao.update(serviceList);
 663                                 }
 664                                 responseString = mapper.writeValueAsString(commonClassDao.getData(ServiceList.class));
 665                         }else{
 666                                 responseString = duplicateResponseString;
 667                         }
 668                         if(fromAPI){
 669                                 return utils.getResultForApi(responseString);
 670                         }else{
 671                                 utils.setResponseData(response, serviceListDatas, responseString);
 672                         }
 673                 }catch (Exception e){
 674                         utils.setErrorResponseData(response, e);
 675                 }
 676                 return null;
 677         }
 678
 679         @RequestMapping(value={"/fw_dictionary/remove_serviceList"}, method={RequestMethod.POST})
 680         public void removeServiceListDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException {
 681                 DictionaryUtils utils = getDictionaryUtilsInstance();
 682                 utils.removeData(request, response, serviceListDatas, ServiceList.class);
 683         }
 684
 685         @RequestMapping(value={"/get_ZoneData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 686         public void getZoneDictionaryEntityData(HttpServletResponse response){
 687                 DictionaryUtils utils = getDictionaryUtilsInstance();
 688                 utils.getData(response, zoneDatas, Zone.class);
 689         }
 690
 691         @RequestMapping(value={"/get_ZoneDictionaryDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 692         public void getZoneDictionaryEntityDataByName(HttpServletResponse response){
 693                 DictionaryUtils utils = getDictionaryUtilsInstance();
 694                 utils.getDataByEntity(response, zoneDatas, zoneName, PrefixList.class);
 695         }
 696
 697         @RequestMapping(value={"/fw_dictionary/save_zoneName"}, method={RequestMethod.POST})
 698         public ModelAndView saveZoneDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 699                 DictionaryUtils utils = getDictionaryUtilsInstance();
 700                 try {
 701                         boolean fromAPI = utils.isRequestFromAPI(request);
 702                         ObjectMapper mapper = new ObjectMapper();
 703                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 704                         JsonNode root = mapper.readTree(request.getReader());
 705                         Zone zone;
 706                         if (fromAPI) {
 707                                 zone = mapper.readValue(root.get(dictionaryFields).toString(), Zone.class);
 708                         } else {
 709                                 zone = mapper.readValue(root.get("zoneDictionaryData").toString(), Zone.class);
 710                         }
 711                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(zone.getZoneName(), zoneName, Zone.class);
 712                         boolean duplicateflag = false;
 713                         if(!duplicateData.isEmpty()){
 714                                 Zone data = (Zone) duplicateData.get(0);
 715                                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 716                                         zone.setId(data.getId());
 717                                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 718                                                 (request.getParameter(operation) == null && (data.getId() != zone.getId()))){
 719                                         duplicateflag = true;
 720                                 }
 721                         }
 722                         String responseString = null;
 723                         if(!duplicateflag){
 724                                 if(zone.getId() == 0){
 725                                         commonClassDao.save(zone);
 726                                 }else{
 727                                         commonClassDao.update(zone);
 728                                 }
 729                                 responseString = mapper.writeValueAsString(commonClassDao.getData(Zone.class));
 730                         }else{
 731                                 responseString = duplicateResponseString;
 732                         }
 733                         if(fromAPI){
 734                                 return utils.getResultForApi(responseString);
 735                         }else{
 736                                 utils.setResponseData(response, zoneDatas, responseString);
 737                         }
 738                 }catch (Exception e){
 739                         utils.setErrorResponseData(response, e);
 740                 }
 741                 return null;
 742         }
 743
 744         @RequestMapping(value={"/fw_dictionary/remove_zone"}, method={RequestMethod.POST})
 745         public void removeZoneDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 746                 DictionaryUtils utils = getDictionaryUtilsInstance();
 747                 utils.removeData(request, response, zoneDatas, Zone.class);
 748         }
 749
 750         @RequestMapping(value={"/get_TermListDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 751         public void getTermListDictionaryEntityDataByName(HttpServletResponse response){
 752                 DictionaryUtils utils = getDictionaryUtilsInstance();
 753                 utils.getDataByEntity(response, termListDictDatas, termName, TermList.class);
 754         }
 755
 756         @RequestMapping(value={"/get_TermListData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 757         public void getTermListDictionaryEntityData(HttpServletResponse response){
 758                 DictionaryUtils utils = getDictionaryUtilsInstance();
 759                 utils.getData(response, termListDictDatas, TermList.class);
 760         }
 761
 762         @RequestMapping(value={"/fw_dictionary/save_termList"}, method={RequestMethod.POST})
 763         public ModelAndView saveTermListDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 764                 DictionaryUtils utils = getDictionaryUtilsInstance();
 765                 try {
 766                         boolean fromAPI = utils.isRequestFromAPI(request);
 767                         ObjectMapper mapper = new ObjectMapper();
 768                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 769                         JsonNode root = mapper.readTree(request.getReader());
 770                         TermList termList;
 771                         TermListData termListDatas;
 772                         String userId = null;
 773                         if(fromAPI){
 774                                 termList = mapper.readValue(root.get(dictionaryFields).toString(), TermList.class);
 775                                 termListDatas = mapper.readValue(root.get(dictionaryFields).toString(), TermListData.class);
 776                                 userId = "API";
 777                         }else{
 778                                 termList = mapper.readValue(root.get("termListDictionaryData").toString(), TermList.class);
 779                                 termListDatas = mapper.readValue(root.get("termListDictionaryData").toString(), TermListData.class);
 780                                 userId = root.get(userid).textValue();
 781                         }
 782
 783                         termList.setFromZones(utils.appendKey(termListDatas.getFromZoneDatas(), option, ","));
 784                         termList.setToZones(utils.appendKey(termListDatas.getToZoneDatas(), option, ","));
 785                         termList.setSrcIPList(utils.appendKey(termListDatas.getSourceListDatas(), option, ","));
 786                         termList.setDestIPList(utils.appendKey(termListDatas.getDestinationListDatas(), option, ","));
 787                         termList.setSrcPortList(utils.appendKey(termListDatas.getSourceServiceDatas(), option, ","));
 788                         termList.setDestPortList(utils.appendKey(termListDatas.getDestinationServiceDatas(), option, ","));
 789                         termList.setAction(utils.appendKey(termListDatas.getActionListDatas(), option, ","));
 790
 791                         UserInfo userInfo = utils.getUserInfo(userId);
 792                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(termList.getTermName(), termName, TermList.class);
 793                         boolean duplicateflag = false;
 794                         if(!duplicateData.isEmpty()){
 795                                 TermList data = (TermList) duplicateData.get(0);
 796                                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 797                                         termList.setId(data.getId());
 798                                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 799                                                 (request.getParameter(operation) == null && (data.getId() != termList.getId()))){
 800                                         duplicateflag = true;
 801                                 }
 802                         }
 803                         String responseString = null;
 804                         if(!duplicateflag){
 805                                 termList.setUserModifiedBy(userInfo);
 806                                 if(termList.getId() == 0){
 807                                         termList.setUserCreatedBy(userInfo);
 808                                         commonClassDao.save(termList);
 809                                 }else{
 810                                         termList.setModifiedDate(new Date());
 811                                         commonClassDao.update(termList);
 812                                 }
 813                                 responseString = mapper.writeValueAsString(commonClassDao.getData(TermList.class));
 814                         }else{
 815                                 responseString = duplicateResponseString;
 816                         }
 817                         if(fromAPI){
 818                                 return utils.getResultForApi(responseString);
 819                         }else{
 820                                 utils.setResponseData(response, termListDictDatas, responseString);
 821                         }
 822                 }catch (Exception e){
 823                         utils.setErrorResponseData(response, e);
 824                 }
 825                 return null;
 826         }
 827
 828         @RequestMapping(value={"/fw_dictionary/remove_termList"}, method={RequestMethod.POST})
 829         public void removeTermListDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 830                 DictionaryUtils utils = getDictionaryUtilsInstance();
 831                 utils.removeData(request, response, termListDictDatas, TermList.class);
 832         }
 833
 834         //ParentList Dictionary Data
 835         @RequestMapping(value={"/get_FWDictionaryListDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 836         public void getFWDictListDictionaryEntityDataByName(HttpServletResponse response){
 837                 DictionaryUtils utils = getDictionaryUtilsInstance();
 838                 utils.getDataByEntity(response, fwDictListDatas, "parentItemName", FirewallDictionaryList.class);
 839         }
 840
 841         @RequestMapping(value={"/get_FWDictionaryListData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 842         public void getFWDictionaryListEntityData(HttpServletResponse response){
 843                 DictionaryUtils utils = getDictionaryUtilsInstance();
 844                 utils.getData(response, fwDictListDatas, FirewallDictionaryList.class);
 845         }
 846
 847         @RequestMapping(value={"/fw_dictionary/save_FWDictionaryList"}, method={RequestMethod.POST})
 848         public ModelAndView saveFWDictionaryList(HttpServletRequest request, HttpServletResponse response) throws IOException{
 849                 DictionaryUtils utils = getDictionaryUtilsInstance();
 850                 try {
 851                         boolean fromAPI = utils.isRequestFromAPI(request);
 852                         ObjectMapper mapper = new ObjectMapper();
 853                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 854                         JsonNode root = mapper.readTree(request.getReader());
 855                         FirewallDictionaryList fwDictList;
 856                         GridData gridData;
 857                         if (fromAPI) {
 858                                 fwDictList = mapper.readValue(root.get(dictionaryFields).toString(), FirewallDictionaryList.class);
 859                                 gridData = mapper.readValue(root.get(dictionaryFields).toString(), GridData.class);
 860                         } else {
 861                                 fwDictList = mapper.readValue(root.get("fwDictListDictionaryData").toString(), FirewallDictionaryList.class);
 862                                 gridData = mapper.readValue(root.get("fwDictListDictionaryData").toString(), GridData.class);
 863                         }
 864
 865                         fwDictList.setServiceList(utils.appendKey(gridData.getAttributes(), option, ","));
 866                         fwDictList.setAddressList(utils.appendKey(gridData.getAlAttributes(), option, ","));
 867
 868                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(fwDictList.getParentItemName(), "parentItemName", FirewallDictionaryList.class);
 869                         boolean duplicateflag = false;
 870                         if(!duplicateData.isEmpty()){
 871                                 FirewallDictionaryList data = (FirewallDictionaryList) duplicateData.get(0);
 872                                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 873                                         fwDictList.setId(data.getId());
 874                                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 875                                                 (request.getParameter(operation) == null && (data.getId() != fwDictList.getId()))){
 876                                         duplicateflag = true;
 877                                 }
 878                         }
 879                         String responseString = null;
 880                         if(!duplicateflag){
 881                                 if(fwDictList.getId() == 0){
 882                                         commonClassDao.save(fwDictList);
 883                                 }else{
 884                                         commonClassDao.update(fwDictList);
 885                                 }
 886                                 responseString = mapper.writeValueAsString(commonClassDao.getData(FirewallDictionaryList.class));
 887                         }else{
 888                                 responseString = duplicateResponseString;
 889                         }
 890                         if(fromAPI){
 891                                 return utils.getResultForApi(responseString);
 892                         }else{
 893                                 utils.setResponseData(response, fwDictListDatas, responseString);
 894                         }
 895                 }
 896                 catch (Exception e){
 897                         utils.setErrorResponseData(response, e);
 898                 }
 899                 return null;
 900         }
 901
 902         @RequestMapping(value={"/fw_dictionary/remove_FWDictionaryList"}, method={RequestMethod.POST})
 903         public void removeFWDictionaryList(HttpServletRequest request, HttpServletResponse response) throws IOException {
 904                 DictionaryUtils utils = getDictionaryUtilsInstance();
 905                 utils.removeData(request, response, fwDictListDatas, FirewallDictionaryList.class);
 906         }
 907
 908
 909         @RequestMapping(value={"/get_TagPickerNameByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 910         public void getTagPickerNameEntityDataByName(HttpServletResponse response){
 911                 DictionaryUtils utils = getDictionaryUtilsInstance();
 912                 utils.getDataByEntity(response, fwTagPickerDatas, tagPickerName, FWTagPicker.class);
 913         }
 914
 915         @RequestMapping(value={"/get_TagPickerListData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 916         public void getTagPickerDictionaryEntityData(HttpServletResponse response){
 917                 DictionaryUtils utils = getDictionaryUtilsInstance();
 918                 utils.getData(response, fwTagPickerDatas, FWTagPicker.class);
 919         }
 920
 921         @RequestMapping(value={"/fw_dictionary/save_fwTagPicker"}, method={RequestMethod.POST})
 922         public ModelAndView saveFirewallTagPickerDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 923                 DictionaryUtils utils = getDictionaryUtilsInstance();
 924                 try {
 925                         boolean fromAPI = utils.isRequestFromAPI(request);
 926                         ObjectMapper mapper = new ObjectMapper();
 927                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 928                         JsonNode root = mapper.readTree(request.getReader());
 929                         FWTagPicker fwTagPicker;
 930                         TagGridValues data;
 931                         String userId = "";
 932                         if (fromAPI) {
 933                                 fwTagPicker = mapper.readValue(root.get(dictionaryFields).toString(), FWTagPicker.class);
 934                                 data = mapper.readValue(root.get(dictionaryFields).toString(), TagGridValues.class);
 935                                 userId = "API";
 936                         } else {
 937                                 fwTagPicker = mapper.readValue(root.get("fwTagPickerDictionaryData").toString(), FWTagPicker.class);
 938                                 data = mapper.readValue(root.get("fwTagPickerDictionaryData").toString(), TagGridValues.class);
 939                                 userId = root.get(userid).textValue();
 940                         }
 941                         fwTagPicker.setTagValues(utils.appendKeyValue(data.getTags(), "#", ":"));
 942
 943                         UserInfo userInfo = utils.getUserInfo(userId);
 944
 945                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(fwTagPicker.getTagPickerName(), tagPickerName, FWTagPicker.class);
 946                         boolean duplicateflag = false;
 947                         if(!duplicateData.isEmpty()){
 948                                 FWTagPicker data1 = (FWTagPicker) duplicateData.get(0);
 949                                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 950                                         fwTagPicker.setId(data1.getId());
 951                                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 952                                                 (request.getParameter(operation) == null && (data1.getId() != fwTagPicker.getId()))){
 953                                         duplicateflag = true;
 954                                 }
 955                         }
 956                         String responseString = null;
 957                         if(!duplicateflag){
 958                                 fwTagPicker.setUserModifiedBy(userInfo);
 959                                 if(fwTagPicker.getId() == 0){
 960                                         fwTagPicker.setUserCreatedBy(userInfo);
 961                                         commonClassDao.save(fwTagPicker);
 962                                 }else{
 963                                         fwTagPicker.setModifiedDate(new Date());
 964                                         commonClassDao.update(fwTagPicker);
 965                                 }
 966                                 responseString = mapper.writeValueAsString(commonClassDao.getData(FWTagPicker.class));
 967                         }else{
 968                                 responseString = duplicateResponseString;
 969                         }
 970                         if(fromAPI){
 971                                 return utils.getResultForApi(responseString);
 972                         }else{
 973                                 utils.setResponseData(response, fwTagPickerDatas, responseString);
 974                         }
 975                 }
 976                 catch (Exception e){
 977                         utils.setErrorResponseData(response, e);
 978                 }
 979                 return null;
 980         }
 981
 982         @RequestMapping(value={"/fw_dictionary/remove_tagPicker"}, method={RequestMethod.POST})
 983         public void removeFirewallTagPickerDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException {
 984                 DictionaryUtils utils = getDictionaryUtilsInstance();
 985                 utils.removeData(request, response, fwTagPickerDatas, FWTagPicker.class);
 986         }
 987
 988         @RequestMapping(value={"/get_TagListData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 989         public void getTagDictionaryEntityData(HttpServletResponse response){
 990                 DictionaryUtils utils = getDictionaryUtilsInstance();
 991                 utils.getData(response, fwTagDatas, FWTag.class);
 992         }
 993
 994         @RequestMapping(value={"/get_TagNameByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 995         public void getTagNameEntityDataByName(HttpServletResponse response){
 996                 DictionaryUtils utils = getDictionaryUtilsInstance();
 997                 utils.getDataByEntity(response, fwTagDatas, "fwTagName", FWTag.class);
 998         }
 999
1000
1001         @RequestMapping(value={"/fw_dictionary/save_fwTag"}, method={RequestMethod.POST})
1002         public ModelAndView saveFirewallTagDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
1003                 DictionaryUtils utils = getDictionaryUtilsInstance();
1004                 try {
1005                         boolean fromAPI = utils.isRequestFromAPI(request);
1006                         ObjectMapper mapper = new ObjectMapper();
1007                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
1008                         JsonNode root = mapper.readTree(request.getReader());
1009                         FWTag fwTag;
1010                         TagGridValues tagGridValues;
1011                         String userId="";
1012                         if(fromAPI){
1013                                 fwTag = mapper.readValue(root.get(dictionaryFields).toString(), FWTag.class);
1014                                 tagGridValues = mapper.readValue(root.get(dictionaryFields).toString(), TagGridValues.class);
1015                                 userId = "API";
1016                         }else{
1017                                 fwTag = mapper.readValue(root.get("fwTagDictionaryData").toString(), FWTag.class);
1018                                 tagGridValues = mapper.readValue(root.get("fwTagDictionaryData").toString(), TagGridValues.class);
1019                                 userId = root.get(userid).textValue();
1020                         }
1021                         fwTag.setTagValues(utils.appendKey(tagGridValues.getTags(), "tags", ","));
1022
1023                         UserInfo userInfo = utils.getUserInfo(userId);
1024                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(fwTag.getFwTagName(), "fwTagName", FWTag.class);
1025                         boolean duplicateflag = false;
1026                         if(!duplicateData.isEmpty()){
1027                                 FWTag data = (FWTag) duplicateData.get(0);
1028                                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
1029                                         fwTag.setId(data.getId());
1030                                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
1031                                                 (request.getParameter(operation) == null && (data.getId() != fwTag.getId()))){
1032                                         duplicateflag = true;
1033                                 }
1034                         }
1035                         String responseString = null;
1036                         if(!duplicateflag){
1037                                 fwTag.setUserModifiedBy(userInfo);
1038                                 if(fwTag.getId() == 0){
1039                                         fwTag.setUserCreatedBy(userInfo);
1040                                         commonClassDao.save(fwTag);
1041                                 }else{
1042                                         fwTag.setModifiedDate(new Date());
1043                                         commonClassDao.update(fwTag);
1044                                 }
1045                                 responseString = mapper.writeValueAsString(commonClassDao.getData(FWTag.class));
1046                         }else{
1047                                 responseString = duplicateResponseString;
1048                         }
1049                         if(fromAPI){
1050                                 return utils.getResultForApi(responseString);
1051                         }else{
1052                                 utils.setResponseData(response, fwTagDatas, responseString);
1053                         }
1054                 }
1055                 catch (Exception e){
1056                         utils.setErrorResponseData(response, e);
1057                 }
1058                 return null;
1059         }
1060
1061         @RequestMapping(value={"/fw_dictionary/remove_tagList"}, method={RequestMethod.POST})
1062         public void removeFirewallTagDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
1063                 DictionaryUtils utils = getDictionaryUtilsInstance();
1064                 utils.removeData(request, response, fwTagDatas, FWTag.class);
1065         }
1066 }
1067
1068 class TagGridValues{
1069         private List<Object> tags;
1070
1071         public List<Object> getTags() {
1072                 return tags;
1073         }
1074
1075         public void setTags(List<Object> tags) {
1076                 this.tags = tags;
1077         }
1078 }
1079
1080 class AGGridData{
1081         private List<Object> attributes;
1082
1083         public List<Object> getAttributes() {
1084                 return attributes;
1085         }
1086
1087         public void setAttributes(List<Object> attributes) {
1088                 this.attributes = attributes;
1089         }
1090 }
1091
1092 class TermListData{
1093         private List<Object> fromZoneDatas;
1094         private List<Object> toZoneDatas;
1095         private List<Object> sourceListDatas;
1096         private List<Object> destinationListDatas;
1097         private List<Object> sourceServiceDatas;
1098         private List<Object> destinationServiceDatas;
1099         private List<Object> actionListDatas;
1100         public List<Object> getFromZoneDatas() {
1101                 return fromZoneDatas;
1102         }
1103         public void setFromZoneDatas(List<Object> fromZoneDatas) {
1104                 this.fromZoneDatas = fromZoneDatas;
1105         }
1106         public List<Object> getToZoneDatas() {
1107                 return toZoneDatas;
1108         }
1109         public void setToZoneDatas(List<Object> toZoneDatas) {
1110                 this.toZoneDatas = toZoneDatas;
1111         }
1112         public List<Object> getSourceListDatas() {
1113                 return sourceListDatas;
1114         }
1115         public void setSourceListDatas(List<Object> sourceListDatas) {
1116                 this.sourceListDatas = sourceListDatas;
1117         }
1118         public List<Object> getDestinationListDatas() {
1119                 return destinationListDatas;
1120         }
1121         public void setDestinationListDatas(List<Object> destinationListDatas) {
1122                 this.destinationListDatas = destinationListDatas;
1123         }
1124         public List<Object> getSourceServiceDatas() {
1125                 return sourceServiceDatas;
1126         }
1127         public void setSourceServiceDatas(List<Object> sourceServiceDatas) {
1128                 this.sourceServiceDatas = sourceServiceDatas;
1129         }
1130         public List<Object> getDestinationServiceDatas() {
1131                 return destinationServiceDatas;
1132         }
1133         public void setDestinationServiceDatas(List<Object> destinationServiceDatas) {
1134                 this.destinationServiceDatas = destinationServiceDatas;
1135         }
1136         public List<Object> getActionListDatas() {
1137                 return actionListDatas;
1138         }
1139         public void setActionListDatas(List<Object> actionListDatas) {
1140                 this.actionListDatas = actionListDatas;
1141         }
1142 }