ECOMP-PAP-REST/src/main/java/org/openecomp/policy/pap/xacml/rest/controller/PolicyScopeDictionaryController.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ECOMP-PAP-REST
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.policy.pap.xacml.rest.controller;
  22
  23 import java.io.PrintWriter;
  24 import java.util.ArrayList;
  25 import java.util.HashMap;
  26 import java.util.List;
  27 import java.util.Map;
  28
  29 import javax.servlet.http.HttpServletRequest;
  30 import javax.servlet.http.HttpServletResponse;
  31
  32 import org.apache.commons.lang.StringUtils;
  33 import org.json.JSONObject;
  34 import org.openecomp.policy.common.logging.flexlogger.FlexLogger;
  35 import org.openecomp.policy.common.logging.flexlogger.Logger;
  36 import org.openecomp.policy.pap.xacml.rest.util.JsonMessage;
  37 import org.openecomp.policy.rest.dao.CommonClassDao;
  38 import org.openecomp.policy.rest.jpa.GroupPolicyScopeList;
  39 import org.openecomp.policy.rest.jpa.PolicyScopeClosedLoop;
  40 import org.openecomp.policy.rest.jpa.PolicyScopeResource;
  41 import org.openecomp.policy.rest.jpa.PolicyScopeService;
  42 import org.openecomp.policy.rest.jpa.PolicyScopeType;
  43 import org.openecomp.policy.rest.jpa.UserInfo;
  44 import org.springframework.beans.factory.annotation.Autowired;
  45 import org.springframework.http.MediaType;
  46 import org.springframework.stereotype.Controller;
  47 import org.springframework.web.bind.annotation.RequestMapping;
  48 import org.springframework.web.servlet.ModelAndView;
  49
  50 import com.fasterxml.jackson.databind.DeserializationFeature;
  51 import com.fasterxml.jackson.databind.JsonNode;
  52 import com.fasterxml.jackson.databind.ObjectMapper;
  53
  54 @Controller
  55 public class PolicyScopeDictionaryController {
  56
  57         private static final Logger LOGGER  = FlexLogger.getLogger(PolicyScopeDictionaryController.class);
  58
  59         private static CommonClassDao commonClassDao;
  60
  61         @Autowired
  62         public PolicyScopeDictionaryController(CommonClassDao commonClassDao){
  63                 PolicyScopeDictionaryController.commonClassDao = commonClassDao;
  64         }
  65
  66         public PolicyScopeDictionaryController(){}
  67
  68         private static String SUCCESSMAPKEY = "successMapKey";
  69
  70         public UserInfo getUserInfo(String loginId){
  71                 UserInfo name = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId", loginId);
  72                 return name;
  73         }
  74
  75         @RequestMapping(value={"/get_GroupPolicyScopeDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
  76         public void getGroupPolicyScopeEntityDataByName(HttpServletRequest request, HttpServletResponse response){
  77                 try{
  78                         Map<String, Object> model = new HashMap<String, Object>();
  79                         ObjectMapper mapper = new ObjectMapper();
  80                         model.put("groupPolicyScopeListDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(GroupPolicyScopeList.class, "name")));
  81                         JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
  82                         JSONObject j = new JSONObject(msg);
  83                         response.getWriter().write(j.toString());
  84                 }
  85                 catch (Exception e){
  86                         LOGGER.error("Exception Occured"+e);
  87                 }
  88         }
  89
  90         @RequestMapping(value={"/get_GroupPolicyScopeData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
  91         public void getGroupPolicyScopeEntityData(HttpServletRequest request, HttpServletResponse response){
  92                 try{
  93                         Map<String, Object> model = new HashMap<String, Object>();
  94                         ObjectMapper mapper = new ObjectMapper();
  95                         model.put("groupPolicyScopeListDatas", mapper.writeValueAsString(commonClassDao.getData(GroupPolicyScopeList.class)));
  96                         JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
  97                         JSONObject j = new JSONObject(msg);
  98                         response.addHeader(SUCCESSMAPKEY, "success");
  99                         response.addHeader("operation", "getDictionary");
 100                         response.getWriter().write(j.toString());
 101                 }
 102                 catch (Exception e){
 103                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 104                         response.addHeader("error", "dictionaryDBQuery");
 105                         LOGGER.error(e);
 106                 }
 107         }
 108
 109         @RequestMapping(value={"/ps_dictionary/save_psGroupPolicyScope"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
 110         public ModelAndView savePSGroupScopeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{
 111                 try {
 112                         boolean duplicateflag = false;
 113                         boolean isFakeUpdate = false;
 114                         boolean duplicateGroupFlag = false;
 115                         boolean fromAPI = false;
 116                         if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) {
 117                                 fromAPI = true;
 118                         }
 119
 120                         ObjectMapper mapper = new ObjectMapper();
 121                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 122                         JsonNode root = mapper.readTree(request.getReader());
 123                         //GroupPolicyScopeList gpdata = (GroupPolicyScopeList)mapper.readValue(root.get("groupPolicyScopeListData").toString(), GroupPolicyScopeList.class);
 124                         GroupPolicyScopeList gpdata = null;
 125                         GroupPolicyScope groupData = null;
 126                         if (fromAPI) {
 127                                 gpdata = (GroupPolicyScopeList)mapper.readValue(root.get("dictionaryFields").toString(), GroupPolicyScopeList.class);
 128                                 try{
 129                                         groupData = (GroupPolicyScope)mapper.readValue(root.get("groupPolicyScopeListData1").toString(), GroupPolicyScope.class);
 130                                 }catch(Exception e){
 131                                         groupData = new GroupPolicyScope();
 132                                         groupData.setResource(root.get("dictionaryFields").get("resource").toString().replace("\"", ""));
 133                                         groupData.setClosedloop(root.get("dictionaryFields").get("closedloop").toString().replace("\"", ""));
 134                                         groupData.setService(root.get("dictionaryFields").get("service").toString().replace("\"", ""));
 135                                         groupData.setType(root.get("dictionaryFields").get("type").toString().replace("\"", ""));
 136                                 }
 137
 138                                 if(!gpdata.getGroupName().startsWith("PolicyScope")){
 139                                         String name = "PolicyScope_" + gpdata.getGroupName();
 140                                         gpdata.setGroupName(name);
 141                                 }
 142
 143                                 //check if update operation or create, get id for data to be updated and update attributeData
 144                                 if (request.getParameter("operation").equals("update")) {
 145
 146                                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(gpdata.getGroupName(), "name", GroupPolicyScopeList.class);
 147                                         int id = 0;
 148                                         for (int i =0; i< duplicateData.size(); i++){
 149                                                 GroupPolicyScopeList data = (GroupPolicyScopeList) duplicateData.get(0);
 150                                                 id = data.getId();
 151                                         }
 152
 153                                         if(id==0){
 154                                                 isFakeUpdate=true;
 155                                                 gpdata.setId(1);
 156                                         } else {
 157                                                 gpdata.setId(id);
 158                                         }
 159
 160                                 }
 161                         } else {
 162                                 gpdata = (GroupPolicyScopeList)mapper.readValue(root.get("groupPolicyScopeListData").toString(), GroupPolicyScopeList.class);
 163
 164                                 try{
 165                                         groupData = (GroupPolicyScope)mapper.readValue(root.get("groupPolicyScopeListData1").toString(), GroupPolicyScope.class);
 166                                 }catch(Exception e){
 167                                         groupData = new GroupPolicyScope();
 168                                         groupData.setResource(root.get("groupPolicyScopeListData1").get("resource").toString().replace("\"", ""));
 169                                         groupData.setClosedloop(root.get("groupPolicyScopeListData1").get("closedloop").toString().replace("\"", ""));
 170                                         groupData.setService(root.get("groupPolicyScopeListData1").get("service").toString().replace("\"", ""));
 171                                         groupData.setType(root.get("groupPolicyScopeListData1").get("type").toString().replace("\"", ""));
 172                                 }
 173                                 if(!gpdata.getGroupName().startsWith("PolicyScope")){
 174                                         String name = "PolicyScope_" + gpdata.getGroupName();
 175                                         gpdata.setGroupName(name);
 176                                 }
 177
 178                         }
 179                         ArrayList<String> valueList = new ArrayList<String>();
 180                         String list = null;
 181                         String resourceValue = groupData.getResource();
 182                         String typeValue = groupData.getType();
 183                         String serviceValue = groupData.getService();
 184                         String closedLoopValue = groupData.getClosedloop();
 185                         valueList.add("resource=" + resourceValue);
 186                         valueList.add("service=" + serviceValue);
 187                         valueList.add("type=" + typeValue);
 188                         valueList.add("closedLoopControlName="  + closedLoopValue);
 189                         list = StringUtils.replaceEach(valueList.toString(), new String[]{"[", "]", " "}, new String[]{"", "", ""});
 190                         gpdata.setGroupList(list);
 191                         if(!gpdata.getGroupName().startsWith("PolicyScope")){
 192                                 String name = "PolicyScope_" + gpdata.getGroupName();
 193                                 gpdata.setGroupName(name);
 194                         }
 195                         if(gpdata.getId() == 0){
 196                                 List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(gpdata.getGroupName(), "name", GroupPolicyScopeList.class);
 197                                 if(!duplicateData.isEmpty()){
 198                                         duplicateflag = true;
 199                                 }else{
 200                                         duplicateData =  commonClassDao.checkDuplicateEntry(gpdata.getGroupList(), "groupList", GroupPolicyScopeList.class);
 201                                         if(!duplicateData.isEmpty()){
 202                                                 duplicateGroupFlag = true;
 203                                         }else{
 204                                                 commonClassDao.save(gpdata);
 205                                         }
 206                                 }
 207                         }else{
 208                                 if(!isFakeUpdate) {
 209                                         List<Object> duplicateGroupList =  commonClassDao.checkExistingGroupListforUpdate(gpdata.getGroupList(), gpdata.getGroupName());
 210                                         if(!duplicateGroupList.isEmpty()) {
 211                                                 duplicateGroupFlag = true;
 212                                         } else {
 213                                                 commonClassDao.update(gpdata);
 214                                         }
 215                                 }
 216                         }
 217                         String responseString = "";
 218                         if(duplicateflag){
 219                                 responseString = "Duplicate";
 220                         }else if(duplicateGroupFlag){
 221                                 responseString = "DuplicateGroup";
 222                         }else{
 223                                 responseString = mapper.writeValueAsString(commonClassDao.getData(GroupPolicyScopeList.class));
 224                         }
 225
 226                         if (fromAPI) {
 227                                 if (responseString!=null && !responseString.equals("Duplicate") && !responseString.equals("DuplicateGroup")) {
 228                                         if(isFakeUpdate){
 229                                                 responseString = "Exists";
 230                                         } else {
 231                                                 responseString = "Success";
 232                                         }
 233                                 }
 234
 235                                 ModelAndView result = new ModelAndView();
 236                                 result.setViewName(responseString);
 237                                 return result;
 238                         } else {
 239
 240                                 response.setCharacterEncoding("UTF-8");
 241                                 response.setContentType("application / json");
 242                                 request.setCharacterEncoding("UTF-8");
 243
 244                                 PrintWriter out = response.getWriter();
 245                                 JSONObject j = new JSONObject("{groupPolicyScopeListDatas: " + responseString + "}");
 246                                 out.write(j.toString());
 247                                 return null;
 248                         }
 249                 }catch (Exception e){
 250                         response.setCharacterEncoding("UTF-8");
 251                         request.setCharacterEncoding("UTF-8");
 252                         PrintWriter out = response.getWriter();
 253                         out.write(e.getMessage());
 254                 }
 255                 return null;
 256         }
 257
 258         @RequestMapping(value={"/ps_dictionary/remove_GroupPolicyScope"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
 259         public ModelAndView removePSGroupScopeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception {
 260                 try{
 261                         ObjectMapper mapper = new ObjectMapper();
 262                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 263                         JsonNode root = mapper.readTree(request.getReader());
 264                         GroupPolicyScopeList ecompData = (GroupPolicyScopeList)mapper.readValue(root.get("data").toString(), GroupPolicyScopeList.class);
 265                         commonClassDao.delete(ecompData);
 266                         response.setCharacterEncoding("UTF-8");
 267                         response.setContentType("application / json");
 268                         request.setCharacterEncoding("UTF-8");
 269
 270                         PrintWriter out = response.getWriter();
 271
 272                         String responseString = mapper.writeValueAsString(commonClassDao.getData(GroupPolicyScopeList.class));
 273                         JSONObject j = new JSONObject("{groupPolicyScopeListDatas: " + responseString + "}");
 274                         out.write(j.toString());
 275
 276                         return null;
 277                 }
 278                 catch (Exception e){
 279                         System.out.println(e);
 280                         response.setCharacterEncoding("UTF-8");
 281                         request.setCharacterEncoding("UTF-8");
 282                         PrintWriter out = response.getWriter();
 283                         out.write(e.getMessage());
 284                 }
 285                 return null;
 286         }
 287
 288         @RequestMapping(value={"/get_PSClosedLoopDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 289         public void getPSClosedLoopEntityDataByName(HttpServletRequest request, HttpServletResponse response){
 290                 try{
 291                         Map<String, Object> model = new HashMap<String, Object>();
 292                         ObjectMapper mapper = new ObjectMapper();
 293                         model.put("psClosedLoopDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(PolicyScopeClosedLoop.class, "name")));
 294                         JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
 295                         JSONObject j = new JSONObject(msg);
 296                         response.getWriter().write(j.toString());
 297                 }
 298                 catch (Exception e){
 299                         LOGGER.error("Exception Occured"+e);
 300                 }
 301         }
 302
 303         @RequestMapping(value={"/get_PSClosedLoopData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 304         public void getPSClosedLoopEntityData(HttpServletRequest request, HttpServletResponse response){
 305                 try{
 306                         Map<String, Object> model = new HashMap<String, Object>();
 307                         ObjectMapper mapper = new ObjectMapper();
 308                         model.put("psClosedLoopDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(PolicyScopeClosedLoop.class)));
 309                         JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
 310                         JSONObject j = new JSONObject(msg);
 311                         response.addHeader(SUCCESSMAPKEY, "success");
 312                         response.addHeader("operation", "getDictionary");
 313                         response.getWriter().write(j.toString());
 314                 }
 315                 catch (Exception e){
 316                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 317                         response.addHeader("error", "dictionaryDBQuery");
 318                         LOGGER.error(e);
 319                 }
 320         }
 321
 322         @RequestMapping(value={"/ps_dictionary/save_psClosedLoop"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
 323         public ModelAndView savePSClosedLoopDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{
 324                 try {
 325                         boolean duplicateflag = false;
 326                         boolean isFakeUpdate = false;
 327                         boolean fromAPI = false;
 328                         if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) {
 329                                 fromAPI = true;
 330                         }
 331                         ObjectMapper mapper = new ObjectMapper();
 332                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 333                         JsonNode root = mapper.readTree(request.getReader());
 334                         PolicyScopeClosedLoop ecompData;
 335                         if (fromAPI) {
 336                                 ecompData = (PolicyScopeClosedLoop)mapper.readValue(root.get("dictionaryFields").toString(), PolicyScopeClosedLoop.class);
 337
 338                                 //check if update operation or create, get id for data to be updated and update attributeData
 339                                 if (request.getParameter("operation").equals("update")) {
 340                                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(ecompData.getName(), "name", PolicyScopeClosedLoop.class);
 341                                         int id = 0;
 342                                         for (int i =0; i< duplicateData.size(); i++){
 343                                                 PolicyScopeClosedLoop data = (PolicyScopeClosedLoop) duplicateData.get(0);
 344                                                 id = data.getId();
 345                                         }
 346
 347                                         if(id==0){
 348                                                 isFakeUpdate=true;
 349                                                 ecompData.setId(1);
 350                                         } else {
 351                                                 ecompData.setId(id);
 352                                         }
 353
 354                                 }
 355                         } else {
 356                                 ecompData = (PolicyScopeClosedLoop)mapper.readValue(root.get("psClosedLoopDictionaryData").toString(), PolicyScopeClosedLoop.class);
 357                         }
 358                         if(ecompData.getId() == 0){
 359                                 List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(ecompData.getName(), "name", PolicyScopeClosedLoop.class);
 360                                 if(!duplicateData.isEmpty()){
 361                                         duplicateflag = true;
 362                                 }else{
 363                                         commonClassDao.save(ecompData);
 364                                 }
 365                         }else{
 366                                 if(!isFakeUpdate) {
 367                                         commonClassDao.update(ecompData);
 368                                 }
 369                         }
 370                         String responseString = "";
 371                         if(duplicateflag){
 372                                 responseString = "Duplicate";
 373                         }else{
 374                                 responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeClosedLoop.class));
 375                         }
 376
 377                         if (fromAPI) {
 378                                 if (responseString!=null && !responseString.equals("Duplicate")) {
 379                                         if(isFakeUpdate){
 380                                                 responseString = "Exists";
 381                                         } else {
 382                                                 responseString = "Success";
 383                                         }
 384                                 }
 385                                 ModelAndView result = new ModelAndView();
 386                                 result.setViewName(responseString);
 387                                 return result;
 388                         } else {
 389                                 response.setCharacterEncoding("UTF-8");
 390                                 response.setContentType("application / json");
 391                                 request.setCharacterEncoding("UTF-8");
 392
 393                                 PrintWriter out = response.getWriter();
 394                                 JSONObject j = new JSONObject("{psClosedLoopDictionaryDatas: " + responseString + "}");
 395
 396                                 out.write(j.toString());
 397
 398                                 return null;
 399                         }
 400
 401                 }catch (Exception e){
 402                         response.setCharacterEncoding("UTF-8");
 403                         request.setCharacterEncoding("UTF-8");
 404                         PrintWriter out = response.getWriter();
 405                         out.write(e.getMessage());
 406                 }
 407                 return null;
 408         }
 409
 410         @RequestMapping(value={"/ps_dictionary/remove_PSClosedLoop"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
 411         public ModelAndView removePSClosedLoopDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception {
 412                 try{
 413                         ObjectMapper mapper = new ObjectMapper();
 414                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 415                         JsonNode root = mapper.readTree(request.getReader());
 416                         PolicyScopeClosedLoop ecompData = (PolicyScopeClosedLoop)mapper.readValue(root.get("data").toString(), PolicyScopeClosedLoop.class);
 417                         commonClassDao.delete(ecompData);
 418                         response.setCharacterEncoding("UTF-8");
 419                         response.setContentType("application / json");
 420                         request.setCharacterEncoding("UTF-8");
 421
 422                         PrintWriter out = response.getWriter();
 423
 424                         String responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeClosedLoop.class));
 425                         JSONObject j = new JSONObject("{psClosedLoopDictionaryDatas: " + responseString + "}");
 426                         out.write(j.toString());
 427
 428                         return null;
 429                 }
 430                 catch (Exception e){
 431                         System.out.println(e);
 432                         response.setCharacterEncoding("UTF-8");
 433                         request.setCharacterEncoding("UTF-8");
 434                         PrintWriter out = response.getWriter();
 435                         out.write(e.getMessage());
 436                 }
 437                 return null;
 438         }
 439
 440         @RequestMapping(value={"/get_PSServiceDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 441         public void getPSServiceEntityDataByName(HttpServletRequest request, HttpServletResponse response){
 442                 try{
 443                         Map<String, Object> model = new HashMap<String, Object>();
 444                         ObjectMapper mapper = new ObjectMapper();
 445                         model.put("psServiceDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(PolicyScopeService.class, "name")));
 446                         JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
 447                         JSONObject j = new JSONObject(msg);
 448                         response.getWriter().write(j.toString());
 449                 }
 450                 catch (Exception e){
 451                         LOGGER.error("Exception Occured"+e);
 452                 }
 453         }
 454
 455         @RequestMapping(value={"/get_PSServiceData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 456         public void getPSServiceEntityData(HttpServletRequest request, HttpServletResponse response){
 457                 try{
 458                         Map<String, Object> model = new HashMap<String, Object>();
 459                         ObjectMapper mapper = new ObjectMapper();
 460                         model.put("psServiceDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(PolicyScopeService.class)));
 461                         JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
 462                         JSONObject j = new JSONObject(msg);
 463                         response.addHeader(SUCCESSMAPKEY, "success");
 464                         response.addHeader("operation", "getDictionary");
 465                         response.getWriter().write(j.toString());
 466                 }
 467                 catch (Exception e){
 468                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 469                         response.addHeader("error", "dictionaryDBQuery");
 470                         LOGGER.error(e);
 471                 }
 472         }
 473
 474         @RequestMapping(value={"/ps_dictionary/save_psService"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
 475         public ModelAndView savePSServiceDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{
 476                 try {
 477                         boolean duplicateflag = false;
 478                         boolean isFakeUpdate = false;
 479                         boolean fromAPI = false;
 480                         if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) {
 481                                 fromAPI = true;
 482                         }
 483                         ObjectMapper mapper = new ObjectMapper();
 484                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 485                         JsonNode root = mapper.readTree(request.getReader());
 486                         PolicyScopeService ecompData;
 487                         if (fromAPI) {
 488                                 ecompData = (PolicyScopeService)mapper.readValue(root.get("dictionaryFields").toString(), PolicyScopeService.class);
 489
 490                                 //check if update operation or create, get id for data to be updated and update attributeData
 491                                 if (request.getParameter("operation").equals("update")) {
 492                                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(ecompData.getName(), "name", PolicyScopeService.class);
 493                                         int id = 0;
 494                                         for (int i =0; i< duplicateData.size(); i++){
 495                                                 PolicyScopeService data = (PolicyScopeService) duplicateData.get(0);
 496                                                 id = data.getId();
 497                                         }
 498                                         if(id==0){
 499                                                 isFakeUpdate=true;
 500                                                 ecompData.setId(1);
 501                                         } else {
 502                                                 ecompData.setId(id);
 503                                         }
 504                                 }
 505                         } else {
 506                                 ecompData = (PolicyScopeService)mapper.readValue(root.get("psServiceDictionaryData").toString(), PolicyScopeService.class);
 507                         }
 508                         if(ecompData.getId() == 0){
 509                                 List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(ecompData.getName(), "name", PolicyScopeService.class);
 510                                 if(!duplicateData.isEmpty()){
 511                                         duplicateflag = true;
 512                                 }else{
 513                                         commonClassDao.save(ecompData);
 514                                 }
 515                         }else{
 516                                 if(!isFakeUpdate) {
 517                                         commonClassDao.update(ecompData);
 518                                 }
 519                         }
 520
 521                         String responseString = "";
 522                         if(duplicateflag){
 523                                 responseString = "Duplicate";
 524                         }else{
 525                                 responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeService.class));
 526                         }
 527
 528                         if (fromAPI) {
 529                                 if (responseString!=null && !responseString.equals("Duplicate")) {
 530                                         if(isFakeUpdate){
 531                                                 responseString = "Exists";
 532                                         } else {
 533                                                 responseString = "Success";
 534                                         }
 535                                 }
 536                                 ModelAndView result = new ModelAndView();
 537                                 result.setViewName(responseString);
 538                                 return result;
 539
 540                         } else {
 541                                 response.setCharacterEncoding("UTF-8");
 542                                 response.setContentType("application / json");
 543                                 request.setCharacterEncoding("UTF-8");
 544
 545                                 PrintWriter out = response.getWriter();
 546                                 JSONObject j = new JSONObject("{psServiceDictionaryDatas: " + responseString + "}");
 547                                 out.write(j.toString());
 548                                 return null;
 549                         }
 550                 }catch (Exception e){
 551                         response.setCharacterEncoding("UTF-8");
 552                         request.setCharacterEncoding("UTF-8");
 553                         PrintWriter out = response.getWriter();
 554                         out.write(e.getMessage());
 555                 }
 556                 return null;
 557         }
 558
 559         @RequestMapping(value={"/ps_dictionary/remove_PSService"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
 560         public ModelAndView removePSServiceDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception {
 561                 try{
 562                         ObjectMapper mapper = new ObjectMapper();
 563                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 564                         JsonNode root = mapper.readTree(request.getReader());
 565                         PolicyScopeService ecompData = (PolicyScopeService)mapper.readValue(root.get("data").toString(), PolicyScopeService.class);
 566                         commonClassDao.delete(ecompData);
 567                         response.setCharacterEncoding("UTF-8");
 568                         response.setContentType("application / json");
 569                         request.setCharacterEncoding("UTF-8");
 570
 571                         PrintWriter out = response.getWriter();
 572
 573                         String responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeService.class));
 574                         JSONObject j = new JSONObject("{psServiceDictionaryDatas: " + responseString + "}");
 575                         out.write(j.toString());
 576
 577                         return null;
 578                 }
 579                 catch (Exception e){
 580                         System.out.println(e);
 581                         response.setCharacterEncoding("UTF-8");
 582                         request.setCharacterEncoding("UTF-8");
 583                         PrintWriter out = response.getWriter();
 584                         out.write(e.getMessage());
 585                 }
 586                 return null;
 587         }
 588
 589         @RequestMapping(value={"/get_PSTypeDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 590         public void getPSTypeEntityDataByName(HttpServletRequest request, HttpServletResponse response){
 591                 try{
 592                         Map<String, Object> model = new HashMap<String, Object>();
 593                         ObjectMapper mapper = new ObjectMapper();
 594                         model.put("psTypeDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(PolicyScopeType.class, "name")));
 595                         JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
 596                         JSONObject j = new JSONObject(msg);
 597                         response.getWriter().write(j.toString());
 598                 }
 599                 catch (Exception e){
 600                         LOGGER.error("Exception Occured"+e);
 601                 }
 602         }
 603
 604         @RequestMapping(value={"/get_PSTypeData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 605         public void getPSTypeEntityData(HttpServletRequest request, HttpServletResponse response){
 606                 try{
 607                         Map<String, Object> model = new HashMap<String, Object>();
 608                         ObjectMapper mapper = new ObjectMapper();
 609                         model.put("psTypeDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(PolicyScopeType.class)));
 610                         JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
 611                         JSONObject j = new JSONObject(msg);
 612                         response.addHeader(SUCCESSMAPKEY, "success");
 613                         response.addHeader("operation", "getDictionary");
 614                         response.getWriter().write(j.toString());
 615                 }
 616                 catch (Exception e){
 617                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 618                         response.addHeader("error", "dictionaryDBQuery");
 619                         LOGGER.error(e);
 620                 }
 621         }
 622
 623         @RequestMapping(value={"/ps_dictionary/save_psType"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
 624         public ModelAndView savePSTypeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{
 625                 try {
 626                         boolean duplicateflag = false;
 627                         boolean isFakeUpdate = false;
 628                         boolean fromAPI = false;
 629                         if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) {
 630                                 fromAPI = true;
 631                         }
 632                         ObjectMapper mapper = new ObjectMapper();
 633                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 634                         JsonNode root = mapper.readTree(request.getReader());
 635                         PolicyScopeType ecompData;
 636                         if (fromAPI) {
 637                                 ecompData = (PolicyScopeType)mapper.readValue(root.get("dictionaryFields").toString(), PolicyScopeType.class);
 638
 639                                 //check if update operation or create, get id for data to be updated and update attributeData
 640                                 if (request.getParameter("operation").equals("update")) {
 641                                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(ecompData.getName(), "name", PolicyScopeType.class);
 642                                         int id = 0;
 643                                         for (int i =0; i< duplicateData.size(); i++){
 644                                                 PolicyScopeType data = (PolicyScopeType) duplicateData.get(0);
 645                                                 id = data.getId();
 646                                         }
 647
 648                                         if(id==0){
 649                                                 isFakeUpdate=true;
 650                                                 ecompData.setId(1);
 651                                         } else {
 652                                                 ecompData.setId(id);
 653                                         }
 654
 655                                 }
 656                         } else {
 657                                 ecompData = (PolicyScopeType)mapper.readValue(root.get("psTypeDictionaryData").toString(), PolicyScopeType.class);
 658                         }
 659                         if(ecompData.getId() == 0){
 660                                 List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(ecompData.getName(), "name", PolicyScopeType.class);
 661                                 if(!duplicateData.isEmpty()){
 662                                         duplicateflag = true;
 663                                 }else{
 664                                         commonClassDao.save(ecompData);
 665                                 }
 666                         }else{
 667                                 if(!isFakeUpdate) {
 668                                         commonClassDao.update(ecompData);
 669                                 }
 670                         }
 671                         String responseString = "";
 672                         if(duplicateflag){
 673                                 responseString = "Duplicate";
 674                         }else{
 675                                 responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeType.class));
 676                         }
 677
 678                         if (fromAPI) {
 679                                 if (responseString!=null && !responseString.equals("Duplicate")) {
 680                                         if(isFakeUpdate){
 681                                                 responseString = "Exists";
 682                                         } else {
 683                                                 responseString = "Success";
 684                                         }
 685
 686                                 }
 687                                 ModelAndView result = new ModelAndView();
 688                                 result.setViewName(responseString);
 689                                 return result;
 690
 691                         } else {
 692
 693                                 response.setCharacterEncoding("UTF-8");
 694                                 response.setContentType("application / json");
 695                                 request.setCharacterEncoding("UTF-8");
 696
 697                                 PrintWriter out = response.getWriter();
 698                                 JSONObject j = new JSONObject("{psTypeDictionaryDatas: " + responseString + "}");
 699
 700                                 out.write(j.toString());
 701
 702                                 return null;
 703                         }
 704
 705                 }catch (Exception e){
 706                         response.setCharacterEncoding("UTF-8");
 707                         request.setCharacterEncoding("UTF-8");
 708                         PrintWriter out = response.getWriter();
 709                         out.write(e.getMessage());
 710                 }
 711                 return null;
 712         }
 713
 714         @RequestMapping(value={"/ps_dictionary/remove_PSType"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
 715         public ModelAndView removePSTypeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception {
 716                 try{
 717                         ObjectMapper mapper = new ObjectMapper();
 718                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 719                         JsonNode root = mapper.readTree(request.getReader());
 720                         PolicyScopeType ecompData = (PolicyScopeType)mapper.readValue(root.get("data").toString(), PolicyScopeType.class);
 721                         commonClassDao.delete(ecompData);
 722                         response.setCharacterEncoding("UTF-8");
 723                         response.setContentType("application / json");
 724                         request.setCharacterEncoding("UTF-8");
 725
 726                         PrintWriter out = response.getWriter();
 727
 728                         String responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeType.class));
 729                         JSONObject j = new JSONObject("{psTypeDictionaryDatas: " + responseString + "}");
 730                         out.write(j.toString());
 731
 732                         return null;
 733                 }
 734                 catch (Exception e){
 735                         System.out.println(e);
 736                         response.setCharacterEncoding("UTF-8");
 737                         request.setCharacterEncoding("UTF-8");
 738                         PrintWriter out = response.getWriter();
 739                         out.write(e.getMessage());
 740                 }
 741                 return null;
 742         }
 743
 744         @RequestMapping(value={"/get_PSResourceDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 745         public void getPSResourceEntityDataByName(HttpServletRequest request, HttpServletResponse response){
 746                 try{
 747                         Map<String, Object> model = new HashMap<String, Object>();
 748                         ObjectMapper mapper = new ObjectMapper();
 749                         model.put("psResourceDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(PolicyScopeResource.class, "name")));
 750                         JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
 751                         JSONObject j = new JSONObject(msg);
 752                         response.getWriter().write(j.toString());
 753                 }
 754                 catch (Exception e){
 755                         LOGGER.error("Exception Occured"+e);
 756                 }
 757         }
 758
 759         @RequestMapping(value={"/get_PSResourceData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 760         public void getPSResourceEntityData(HttpServletRequest request, HttpServletResponse response){
 761                 try{
 762                         Map<String, Object> model = new HashMap<String, Object>();
 763                         ObjectMapper mapper = new ObjectMapper();
 764                         model.put("psResourceDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(PolicyScopeResource.class)));
 765                         JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
 766                         JSONObject j = new JSONObject(msg);
 767                         response.addHeader("successMapKey", "success");
 768                         response.addHeader("operation", "getDictionary");
 769                         response.getWriter().write(j.toString());
 770                 }
 771                 catch (Exception e){
 772                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 773                         response.addHeader("error", "dictionaryDBQuery");
 774                         LOGGER.error(e);
 775                 }
 776         }
 777
 778         @RequestMapping(value={"/ps_dictionary/save_psResource"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
 779         public ModelAndView savePSResourceDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{
 780                 try {
 781                         boolean duplicateflag = false;
 782                         boolean isFakeUpdate = false;
 783                         boolean fromAPI = false;
 784                         if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) {
 785                                 fromAPI = true;
 786                         }
 787                         ObjectMapper mapper = new ObjectMapper();
 788                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 789                         JsonNode root = mapper.readTree(request.getReader());
 790                         PolicyScopeResource ecompData;
 791                         if (fromAPI) {
 792                                 ecompData = (PolicyScopeResource)mapper.readValue(root.get("dictionaryFields").toString(), PolicyScopeResource.class);
 793
 794                                 //check if update operation or create, get id for data to be updated and update attributeData
 795                                 if (request.getParameter("operation").equals("update")) {
 796                                         List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(ecompData.getName(), "name", PolicyScopeResource.class);
 797                                         int id = 0;
 798                                         PolicyScopeResource data = (PolicyScopeResource) duplicateData.get(0);
 799                                         id = data.getId();
 800
 801                                         if(id==0){
 802                                                 isFakeUpdate=true;
 803                                                 ecompData.setId(1);
 804                                         } else {
 805                                                 ecompData.setId(id);
 806                                         }
 807                                 }
 808                         } else {
 809                                 ecompData = (PolicyScopeResource)mapper.readValue(root.get("psResourceDictionaryData").toString(), PolicyScopeResource.class);
 810                         }
 811                         if(ecompData.getId() == 0){
 812                                 List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(ecompData.getName(), "name", PolicyScopeResource.class);
 813                                 if(!duplicateData.isEmpty()){
 814                                         duplicateflag = true;
 815                                 }else{
 816                                         commonClassDao.save(ecompData);
 817                                 }
 818                         }else{
 819                                 if(!isFakeUpdate) {
 820                                         commonClassDao.update(ecompData);
 821                                 }
 822                         }
 823                         String responseString = "";
 824                         if(duplicateflag){
 825                                 responseString = "Duplicate";
 826                         }else{
 827                                 responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeResource.class));
 828                         }
 829
 830                         if (fromAPI) {
 831                                 if (responseString!=null && !responseString.equals("Duplicate")) {
 832                                         if(isFakeUpdate){
 833                                                 responseString = "Exists";
 834                                         } else {
 835                                                 responseString = "Success";
 836                                         }
 837
 838                                 }
 839                                 ModelAndView result = new ModelAndView();
 840                                 result.setViewName(responseString);
 841                                 return result;
 842
 843                         } else {
 844
 845                                 response.setCharacterEncoding("UTF-8");
 846                                 response.setContentType("application / json");
 847                                 request.setCharacterEncoding("UTF-8");
 848
 849                                 PrintWriter out = response.getWriter();
 850                                 JSONObject j = new JSONObject("{psResourceDictionaryDatas: " + responseString + "}");
 851
 852                                 out.write(j.toString());
 853
 854                                 return null;
 855                         }
 856
 857                 }catch (Exception e){
 858                         response.setCharacterEncoding("UTF-8");
 859                         request.setCharacterEncoding("UTF-8");
 860                         PrintWriter out = response.getWriter();
 861                         out.write(e.getMessage());
 862                 }
 863                 return null;
 864         }
 865
 866         @RequestMapping(value={"/ps_dictionary/remove_PSResource"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
 867         public ModelAndView removePSResourceDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception {
 868                 try{
 869                         ObjectMapper mapper = new ObjectMapper();
 870                         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 871                         JsonNode root = mapper.readTree(request.getReader());
 872                         PolicyScopeResource ecompData = (PolicyScopeResource)mapper.readValue(root.get("data").toString(), PolicyScopeResource.class);
 873                         commonClassDao.delete(ecompData);
 874                         response.setCharacterEncoding("UTF-8");
 875                         response.setContentType("application / json");
 876                         request.setCharacterEncoding("UTF-8");
 877
 878                         PrintWriter out = response.getWriter();
 879
 880                         String responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeResource.class));
 881                         JSONObject j = new JSONObject("{psResourceDictionaryDatas: " + responseString + "}");
 882                         out.write(j.toString());
 883
 884                         return null;
 885                 }
 886                 catch (Exception e){
 887                         System.out.println(e);
 888                         response.setCharacterEncoding("UTF-8");
 889                         request.setCharacterEncoding("UTF-8");
 890                         PrintWriter out = response.getWriter();
 891                         out.write(e.getMessage());
 892                 }
 893                 return null;
 894         }
 895 }
 896
 897 class GroupPolicyScope{
 898         String resource;
 899         String type;
 900         String service;
 901         String closedloop;
 902         public String getResource() {
 903                 return resource;
 904         }
 905         public void setResource(String resource) {
 906                 this.resource = resource;
 907         }
 908         public String getType() {
 909                 return type;
 910         }
 911         public void setType(String type) {
 912                 this.type = type;
 913         }
 914         public String getService() {
 915                 return service;
 916         }
 917         public void setService(String service) {
 918                 this.service = service;
 919         }
 920         public String getClosedloop() {
 921                 return closedloop;
 922         }
 923         public void setClosedloop(String closedloop) {
 924                 this.closedloop = closedloop;
 925         }
 926
 927 }