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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP-PAP-REST
   4  * ================================================================================
   5  * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.pap.xacml.rest.controller;
  22
  23 import java.io.IOException;
  24 import java.util.ArrayList;
  25 import java.util.List;
  26
  27 import javax.servlet.http.HttpServletRequest;
  28 import javax.servlet.http.HttpServletResponse;
  29
  30 import org.apache.commons.lang.StringUtils;
  31 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  32 import org.onap.policy.common.logging.flexlogger.Logger;
  33 import org.onap.policy.pap.xacml.rest.util.DictionaryUtils;
  34 import org.onap.policy.rest.dao.CommonClassDao;
  35 import org.onap.policy.rest.jpa.GroupPolicyScopeList;
  36 import org.onap.policy.rest.jpa.OnapName;
  37 import org.onap.policy.rest.jpa.PolicyScopeClosedLoop;
  38 import org.onap.policy.rest.jpa.PolicyScopeResource;
  39 import org.onap.policy.rest.jpa.PolicyScopeService;
  40 import org.onap.policy.rest.jpa.PolicyScopeType;
  41 import org.springframework.beans.factory.annotation.Autowired;
  42 import org.springframework.http.MediaType;
  43 import org.springframework.stereotype.Controller;
  44 import org.springframework.web.bind.annotation.RequestMapping;
  45 import org.springframework.web.bind.annotation.RequestMethod;
  46 import org.springframework.web.servlet.ModelAndView;
  47
  48 import com.fasterxml.jackson.databind.DeserializationFeature;
  49 import com.fasterxml.jackson.databind.JsonNode;
  50 import com.fasterxml.jackson.databind.ObjectMapper;
  51
  52 @Controller
  53 public class PolicyScopeDictionaryController {
  54
  55     private static final Logger LOGGER  = FlexLogger.getLogger(PolicyScopeDictionaryController.class);
  56
  57     private static CommonClassDao commonClassDao;
  58     private static String operation = "operation";
  59     private static String groupPolicyScopeListData1 = "groupPolicyScopeListData1";
  60     private static String policyScope= "PolicyScope";
  61     private static String duplicateResponseString = "Duplicate";
  62     private static String groupPolicyScopeDatas = "groupPolicyScopeListDatas";
  63     private static String dictionaryFields = "dictionaryFields";
  64     private static String psCLDatas = "psClosedLoopDictionaryDatas";
  65     private static String psServiceDatas = "psServiceDictionaryDatas";
  66     private static String psTypeDatas = "psTypeDictionaryDatas";
  67     private static String psResourceDatas = "psResourceDictionaryDatas";
  68
  69     public PolicyScopeDictionaryController(){
  70         super();
  71     }
  72
  73     private DictionaryUtils getDictionaryUtilsInstance(){
  74         return DictionaryUtils.getDictionaryUtils();
  75     }
  76
  77     @Autowired
  78     public PolicyScopeDictionaryController(CommonClassDao commonClassDao){
  79         PolicyScopeDictionaryController.commonClassDao = commonClassDao;
  80     }
  81
  82     public void setCommonClassDao(CommonClassDao commonClassDao){
  83         PolicyScopeDictionaryController.commonClassDao = commonClassDao;
  84     }
  85
  86     @RequestMapping(value={"/get_GroupPolicyScopeDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
  87     public void getGroupPolicyScopeEntityDataByName(HttpServletResponse response){
  88         DictionaryUtils utils = getDictionaryUtilsInstance();
  89         utils.getDataByEntity(response, groupPolicyScopeDatas, "name", GroupPolicyScopeList.class);
  90     }
  91
  92     @RequestMapping(value={"/get_GroupPolicyScopeData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
  93     public void getGroupPolicyScopeEntityData(HttpServletResponse response){
  94         DictionaryUtils utils = getDictionaryUtilsInstance();
  95         utils.getData(response, groupPolicyScopeDatas, GroupPolicyScopeList.class);
  96     }
  97
  98     @RequestMapping(value={"/ps_dictionary/save_psGroupPolicyScope"}, method={RequestMethod.POST})
  99     public ModelAndView savePSGroupScopeDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 100         DictionaryUtils utils = getDictionaryUtilsInstance();
 101         try {
 102             boolean fromAPI = utils.isRequestFromAPI(request);
 103             ObjectMapper mapper = new ObjectMapper();
 104             mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 105             JsonNode root = mapper.readTree(request.getReader());
 106             GroupPolicyScopeList gpdata = null;
 107             GroupPolicyScope groupData = null;
 108             boolean duplicateGroupFlag = false;
 109             if (fromAPI) {
 110                 gpdata = mapper.readValue(root.get(dictionaryFields).toString(), GroupPolicyScopeList.class);
 111                 try{
 112                     groupData = mapper.readValue(root.get(groupPolicyScopeListData1).toString(), GroupPolicyScope.class);
 113                 }catch(Exception e){
 114                     groupData = new GroupPolicyScope();
 115                     groupData.setResource(root.get(dictionaryFields).get("resource").toString().replace("\"", ""));
 116                     groupData.setClosedloop(root.get(dictionaryFields).get("closedloop").toString().replace("\"", ""));
 117                     groupData.setService(root.get(dictionaryFields).get("service").toString().replace("\"", ""));
 118                     groupData.setType(root.get(dictionaryFields).get("type").toString().replace("\"", ""));
 119                     LOGGER.error(e);
 120                 }
 121             } else {
 122                 gpdata = mapper.readValue(root.get("groupPolicyScopeListData").toString(), GroupPolicyScopeList.class);
 123                 try{
 124                     groupData = mapper.readValue(root.get(groupPolicyScopeListData1).toString(), GroupPolicyScope.class);
 125                 }catch(Exception e){
 126                     LOGGER.error(e);
 127                     groupData = new GroupPolicyScope();
 128                     groupData.setResource(root.get(groupPolicyScopeListData1).get("resource").toString().replace("\"", ""));
 129                     groupData.setClosedloop(root.get(groupPolicyScopeListData1).get("closedloop").toString().replace("\"", ""));
 130                     groupData.setService(root.get(groupPolicyScopeListData1).get("service").toString().replace("\"", ""));
 131                     groupData.setType(root.get(groupPolicyScopeListData1).get("type").toString().replace("\"", ""));
 132                 }
 133             }
 134             if(!gpdata.getGroupName().startsWith(policyScope)){
 135                 String name = "PolicyScope_" + gpdata.getGroupName();
 136                 gpdata.setGroupName(name);
 137             }
 138             ArrayList<String> valueList = new ArrayList<>();
 139             String resourceValue = groupData.getResource();
 140             String typeValue = groupData.getType();
 141             String serviceValue = groupData.getService();
 142             String closedLoopValue = groupData.getClosedloop();
 143             valueList.add("resource=" + resourceValue);
 144             valueList.add("service=" + serviceValue);
 145             valueList.add("type=" + typeValue);
 146             valueList.add("closedLoopControlName="  + closedLoopValue);
 147             String list = StringUtils.replaceEach(valueList.toString(), new String[]{"[", "]", " "}, new String[]{"", "", ""});
 148             gpdata.setGroupList(list);
 149
 150             List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(gpdata.getGroupName(), "name", GroupPolicyScopeList.class);
 151             if(duplicateData.isEmpty()){
 152                 duplicateData =  commonClassDao.checkDuplicateEntry(gpdata.getGroupList(), "groupList", GroupPolicyScopeList.class);
 153                 if(duplicateData.isEmpty()){
 154                     duplicateGroupFlag = true;
 155                 }
 156             }
 157             boolean duplicateflag = false;
 158             if(!duplicateData.isEmpty()){
 159                 GroupPolicyScopeList data = (GroupPolicyScopeList) duplicateData.get(0);
 160                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 161                     gpdata.setId(data.getId());
 162                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 163                         (request.getParameter(operation) == null && (data.getId() != gpdata.getId()))){
 164                     duplicateflag = true;
 165                 }
 166             }
 167             String responseString = null;
 168             if(!duplicateflag && !duplicateGroupFlag){
 169                 if(gpdata.getId() == 0){
 170                     commonClassDao.save(gpdata);
 171                 }else{
 172                     commonClassDao.update(gpdata);
 173                 }
 174                 responseString = mapper.writeValueAsString(commonClassDao.getData(GroupPolicyScopeList.class));
 175             }else if(duplicateGroupFlag){
 176                 responseString = "DuplicateGroup";
 177             }else{
 178                 responseString = duplicateResponseString;
 179             }
 180             if(fromAPI){
 181                 return utils.getResultForApi(responseString);
 182             }else{
 183                 utils.setResponseData(response, groupPolicyScopeDatas, responseString);
 184             }
 185         }catch (Exception e){
 186             utils.setErrorResponseData(response, e);
 187         }
 188         return null;
 189     }
 190
 191     @RequestMapping(value={"/ps_dictionary/remove_GroupPolicyScope"}, method={RequestMethod.POST})
 192     public void removePSGroupScopeDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException {
 193         DictionaryUtils utils = getDictionaryUtilsInstance();
 194         utils.removeData(request, response, groupPolicyScopeDatas, GroupPolicyScopeList.class);
 195     }
 196
 197     @RequestMapping(value={"/get_PSClosedLoopDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 198     public void getPSClosedLoopEntityDataByName(HttpServletResponse response){
 199         DictionaryUtils utils = getDictionaryUtilsInstance();
 200         utils.getDataByEntity(response, psCLDatas, "name", OnapName.class);
 201     }
 202
 203     @RequestMapping(value={"/get_PSClosedLoopData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 204     public void getPSClosedLoopEntityData(HttpServletResponse response){
 205         DictionaryUtils utils = getDictionaryUtilsInstance();
 206         utils.getData(response, psCLDatas, PolicyScopeClosedLoop.class);
 207     }
 208
 209     @RequestMapping(value={"/ps_dictionary/save_psClosedLoop"}, method={RequestMethod.POST})
 210     public ModelAndView savePSClosedLoopDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 211         DictionaryUtils utils = getDictionaryUtilsInstance();
 212         try {
 213             boolean fromAPI = utils.isRequestFromAPI(request);
 214             ObjectMapper mapper = new ObjectMapper();
 215             mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 216             JsonNode root = mapper.readTree(request.getReader());
 217             PolicyScopeClosedLoop onapData;
 218             if(fromAPI){
 219                 onapData = mapper.readValue(root.get(dictionaryFields).toString(), PolicyScopeClosedLoop.class);
 220             }else{
 221                 onapData = mapper.readValue(root.get("psClosedLoopDictionaryData").toString(), PolicyScopeClosedLoop.class);
 222             }
 223
 224             List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(onapData.getName(), "name", PolicyScopeClosedLoop.class);
 225             boolean duplicateflag = false;
 226             if(!duplicateData.isEmpty()){
 227                 PolicyScopeClosedLoop data = (PolicyScopeClosedLoop) duplicateData.get(0);
 228                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 229                     onapData.setId(data.getId());
 230                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 231                         (request.getParameter(operation) == null && (data.getId() != onapData.getId()))){
 232                     duplicateflag = true;
 233                 }
 234             }
 235             String responseString = null;
 236             if(!duplicateflag){
 237                 if(onapData.getId() == 0){
 238                     commonClassDao.save(onapData);
 239                 }else{
 240                     commonClassDao.update(onapData);
 241                 }
 242                 responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeClosedLoop.class));
 243             }else{
 244                 responseString = duplicateResponseString;
 245             }
 246             if(fromAPI){
 247                 return utils.getResultForApi(responseString);
 248             }else{
 249                 utils.setResponseData(response, psCLDatas, responseString);
 250             }
 251         }catch (Exception e){
 252             utils.setErrorResponseData(response, e);
 253         }
 254         return null;
 255     }
 256
 257     @RequestMapping(value={"/ps_dictionary/remove_PSClosedLoop"}, method={RequestMethod.POST})
 258     public void removePSClosedLoopDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException {
 259         DictionaryUtils utils = getDictionaryUtilsInstance();
 260         utils.removeData(request, response, psCLDatas, PolicyScopeClosedLoop.class);
 261     }
 262
 263     @RequestMapping(value={"/get_PSServiceDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 264     public void getPSServiceEntityDataByName(HttpServletResponse response){
 265         DictionaryUtils utils = getDictionaryUtilsInstance();
 266         utils.getDataByEntity(response, psServiceDatas, "name", PolicyScopeService.class);
 267     }
 268
 269     @RequestMapping(value={"/get_PSServiceData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 270     public void getPSServiceEntityData(HttpServletResponse response){
 271         DictionaryUtils utils = getDictionaryUtilsInstance();
 272         utils.getData(response, psServiceDatas, PolicyScopeService.class);
 273     }
 274
 275     @RequestMapping(value={"/ps_dictionary/save_psService"}, method={RequestMethod.POST})
 276     public ModelAndView savePSServiceDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 277         DictionaryUtils utils = getDictionaryUtilsInstance();
 278         try {
 279             boolean fromAPI = utils.isRequestFromAPI(request);
 280             ObjectMapper mapper = new ObjectMapper();
 281             mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 282             JsonNode root = mapper.readTree(request.getReader());
 283             PolicyScopeService onapData;
 284             if (fromAPI) {
 285                 onapData = mapper.readValue(root.get(dictionaryFields).toString(), PolicyScopeService.class);
 286             } else {
 287                 onapData = mapper.readValue(root.get("psServiceDictionaryData").toString(), PolicyScopeService.class);
 288             }
 289
 290             List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(onapData.getName(), "name", PolicyScopeService.class);
 291             boolean duplicateflag = false;
 292             if(!duplicateData.isEmpty()){
 293                 PolicyScopeService data = (PolicyScopeService) duplicateData.get(0);
 294                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 295                     onapData.setId(data.getId());
 296                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 297                         (request.getParameter(operation) == null && (data.getId() != onapData.getId()))){
 298                     duplicateflag = true;
 299                 }
 300             }
 301             String responseString = null;
 302             if(!duplicateflag){
 303                 if(onapData.getId() == 0){
 304                     commonClassDao.save(onapData);
 305                 }else{
 306                     commonClassDao.update(onapData);
 307                 }
 308                 responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeService.class));
 309             }else{
 310                 responseString = duplicateResponseString;
 311             }
 312             if(fromAPI){
 313                 return utils.getResultForApi(responseString);
 314             }else{
 315                 utils.setResponseData(response, psServiceDatas, responseString);
 316             }
 317         }catch (Exception e){
 318             utils.setErrorResponseData(response, e);
 319         }
 320         return null;
 321     }
 322
 323     @RequestMapping(value={"/ps_dictionary/remove_PSService"}, method={RequestMethod.POST})
 324     public void removePSServiceDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 325         DictionaryUtils utils = getDictionaryUtilsInstance();
 326         utils.removeData(request, response, psServiceDatas, PolicyScopeService.class);
 327     }
 328
 329     @RequestMapping(value={"/get_PSTypeDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 330     public void getPSTypeEntityDataByName(HttpServletResponse response){
 331         DictionaryUtils utils = getDictionaryUtilsInstance();
 332         utils.getDataByEntity(response, psTypeDatas, "name", PolicyScopeType.class);
 333     }
 334
 335     @RequestMapping(value={"/get_PSTypeData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 336     public void getPSTypeEntityData(HttpServletResponse response){
 337         DictionaryUtils utils = getDictionaryUtilsInstance();
 338         utils.getData(response, psTypeDatas, PolicyScopeType.class);
 339     }
 340
 341     @RequestMapping(value={"/ps_dictionary/save_psType"}, method={RequestMethod.POST})
 342     public ModelAndView savePSTypeDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 343         DictionaryUtils utils = getDictionaryUtilsInstance();
 344         try {
 345             boolean fromAPI = utils.isRequestFromAPI(request);
 346             ObjectMapper mapper = new ObjectMapper();
 347             mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 348             JsonNode root = mapper.readTree(request.getReader());
 349             PolicyScopeType onapData;
 350             if(fromAPI){
 351                 onapData = mapper.readValue(root.get(dictionaryFields).toString(), PolicyScopeType.class);
 352             }else{
 353                 onapData = mapper.readValue(root.get("psTypeDictionaryData").toString(), PolicyScopeType.class);
 354             }
 355
 356             List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(onapData.getName(), "name", PolicyScopeType.class);
 357             boolean duplicateflag = false;
 358             if(!duplicateData.isEmpty()){
 359                 PolicyScopeType data = (PolicyScopeType) duplicateData.get(0);
 360                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 361                     onapData.setId(data.getId());
 362                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 363                         (request.getParameter(operation) == null && (data.getId() != onapData.getId()))){
 364                     duplicateflag = true;
 365                 }
 366             }
 367             String responseString = null;
 368             if(!duplicateflag){
 369                 if(onapData.getId() == 0){
 370                     commonClassDao.save(onapData);
 371                 }else{
 372                     commonClassDao.update(onapData);
 373                 }
 374                 responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeType.class));
 375             }else{
 376                 responseString = duplicateResponseString;
 377             }
 378             if(fromAPI){
 379                 return utils.getResultForApi(responseString);
 380             }else{
 381                 utils.setResponseData(response, psTypeDatas, responseString);
 382             }
 383         }catch (Exception e){
 384             utils.setErrorResponseData(response, e);
 385         }
 386         return null;
 387     }
 388
 389     @RequestMapping(value={"/ps_dictionary/remove_PSType"}, method={RequestMethod.POST})
 390     public void removePSTypeDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException {
 391         DictionaryUtils utils = getDictionaryUtilsInstance();
 392         utils.removeData(request, response, psTypeDatas, PolicyScopeType.class);
 393     }
 394
 395     @RequestMapping(value={"/get_PSResourceDataByName"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 396     public void getPSResourceEntityDataByName(HttpServletResponse response){
 397         DictionaryUtils utils = getDictionaryUtilsInstance();
 398         utils.getDataByEntity(response, psResourceDatas, "name", PolicyScopeResource.class);
 399     }
 400
 401     @RequestMapping(value={"/get_PSResourceData"}, method={RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
 402     public void getPSResourceEntityData(HttpServletResponse response){
 403         DictionaryUtils utils = getDictionaryUtilsInstance();
 404         utils.getData(response, psResourceDatas, PolicyScopeResource.class);
 405     }
 406
 407     @RequestMapping(value={"/ps_dictionary/save_psResource"}, method={RequestMethod.POST})
 408     public ModelAndView savePSResourceDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException{
 409         DictionaryUtils utils = getDictionaryUtilsInstance();
 410         try {
 411             boolean fromAPI = utils.isRequestFromAPI(request);
 412             ObjectMapper mapper = new ObjectMapper();
 413             mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 414             JsonNode root = mapper.readTree(request.getReader());
 415             PolicyScopeResource onapData;
 416             if (fromAPI) {
 417                 onapData = mapper.readValue(root.get(dictionaryFields).toString(), PolicyScopeResource.class);
 418             } else {
 419                 onapData = mapper.readValue(root.get("psResourceDictionaryData").toString(), PolicyScopeResource.class);
 420             }
 421
 422             List<Object> duplicateData =  commonClassDao.checkDuplicateEntry(onapData.getName(), "name", PolicyScopeResource.class);
 423             boolean duplicateflag = false;
 424             if(!duplicateData.isEmpty()){
 425                 PolicyScopeResource data = (PolicyScopeResource) duplicateData.get(0);
 426                 if(request.getParameter(operation) != null && "update".equals(request.getParameter(operation))){
 427                     onapData.setId(data.getId());
 428                 }else if((request.getParameter(operation) != null && !"update".equals(request.getParameter(operation))) ||
 429                         (request.getParameter(operation) == null && (data.getId() != onapData.getId()))){
 430                     duplicateflag = true;
 431                 }
 432             }
 433             String responseString = null;
 434             if(!duplicateflag){
 435                 if(onapData.getId() == 0){
 436                     commonClassDao.save(onapData);
 437                 }else{
 438                     commonClassDao.update(onapData);
 439                 }
 440                 responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeResource.class));
 441             }else{
 442                 responseString = duplicateResponseString;
 443             }
 444             if(fromAPI){
 445                 return utils.getResultForApi(responseString);
 446             }else{
 447                 utils.setResponseData(response, psResourceDatas, responseString);
 448             }
 449         }catch (Exception e){
 450             utils.setErrorResponseData(response, e);
 451         }
 452         return null;
 453     }
 454
 455     @RequestMapping(value={"/ps_dictionary/remove_PSResource"}, method={RequestMethod.POST})
 456     public void removePSResourceDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException {
 457         DictionaryUtils utils = getDictionaryUtilsInstance();
 458         utils.removeData(request, response, psResourceDatas, PolicyScopeResource.class);
 459     }
 460 }
 461
 462 class GroupPolicyScope{
 463     String resource;
 464     String type;
 465     String service;
 466     String closedloop;
 467     public String getResource() {
 468         return resource;
 469     }
 470     public void setResource(String resource) {
 471         this.resource = resource;
 472     }
 473     public String getType() {
 474         return type;
 475     }
 476     public void setType(String type) {
 477         this.type = type;
 478     }
 479     public String getService() {
 480         return service;
 481     }
 482     public void setService(String service) {
 483         this.service = service;
 484     }
 485     public String getClosedloop() {
 486         return closedloop;
 487     }
 488     public void setClosedloop(String closedloop) {
 489         this.closedloop = closedloop;
 490     }
 491
 492 }