2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.onap.policy.pap.xacml.rest.controller;
23 import java.io.IOException;
24 import java.io.PrintWriter;
25 import java.io.UnsupportedEncodingException;
26 import java.util.Date;
27 import java.util.HashMap;
28 import java.util.LinkedHashMap;
29 import java.util.List;
32 import javax.servlet.http.HttpServletRequest;
33 import javax.servlet.http.HttpServletResponse;
35 import org.json.JSONObject;
36 import org.onap.policy.common.logging.flexlogger.FlexLogger;
37 import org.onap.policy.common.logging.flexlogger.Logger;
38 import org.onap.policy.pap.xacml.rest.adapters.GridData;
39 import org.onap.policy.pap.xacml.rest.util.JsonMessage;
40 import org.onap.policy.rest.dao.CommonClassDao;
41 import org.onap.policy.rest.jpa.ClosedLoopD2Services;
42 import org.onap.policy.rest.jpa.ClosedLoopSite;
43 import org.onap.policy.rest.jpa.PEPOptions;
44 import org.onap.policy.rest.jpa.UserInfo;
45 import org.onap.policy.rest.jpa.VNFType;
46 import org.onap.policy.rest.jpa.VSCLAction;
47 import org.onap.policy.rest.jpa.VarbindDictionary;
48 import org.onap.policy.xacml.api.XACMLErrorConstants;
49 import org.springframework.beans.factory.annotation.Autowired;
50 import org.springframework.http.MediaType;
51 import org.springframework.stereotype.Controller;
52 import org.springframework.web.bind.annotation.RequestMapping;
53 import org.springframework.web.servlet.ModelAndView;
55 import com.fasterxml.jackson.databind.DeserializationFeature;
56 import com.fasterxml.jackson.databind.JsonNode;
57 import com.fasterxml.jackson.databind.ObjectMapper;
60 public class ClosedLoopDictionaryController{
62 private static final Logger LOGGER = FlexLogger.getLogger(ClosedLoopDictionaryController.class);
64 private static CommonClassDao commonClassDao;
67 public ClosedLoopDictionaryController(CommonClassDao commonClassDao){
68 ClosedLoopDictionaryController.commonClassDao = commonClassDao;
71 public ClosedLoopDictionaryController(){}
73 public UserInfo getUserInfo(String loginId){
74 UserInfo name = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId", loginId);
79 @RequestMapping(value={"/get_VSCLActionDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
80 public void getVSCLActionDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){
82 Map<String, Object> model = new HashMap<>();
83 ObjectMapper mapper = new ObjectMapper();
84 model.put("vsclActionDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(VSCLAction.class, "vsclaction")));
85 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
86 JSONObject j = new JSONObject(msg);
87 response.getWriter().write(j.toString());
90 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
95 @RequestMapping(value={"/get_VSCLActionData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
96 public void getVSCLActionDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){
98 Map<String, Object> model = new HashMap<>();
99 ObjectMapper mapper = new ObjectMapper();
100 model.put("vsclActionDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(VSCLAction.class)));
101 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
102 JSONObject j = new JSONObject(msg);
103 response.addHeader("successMapKey", "success");
104 response.addHeader("operation", "getDictionary");
105 response.getWriter().write(j.toString());
108 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
109 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
110 response.addHeader("error", "dictionaryDBQuery");
114 @RequestMapping(value={"/get_VNFTypeDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
115 public void getVNFTypeDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){
117 Map<String, Object> model = new HashMap<>();
118 ObjectMapper mapper = new ObjectMapper();
119 model.put("vnfTypeDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(VNFType.class, "vnftype")));
120 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
121 JSONObject j = new JSONObject(msg);
122 response.addHeader("successMapKey", "success");
123 response.addHeader("operation", "getDictionary");
124 response.getWriter().write(j.toString());
127 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
131 @RequestMapping(value={"/get_VNFTypeData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
132 public void getVNFTypeDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){
134 Map<String, Object> model = new HashMap<>();
135 ObjectMapper mapper = new ObjectMapper();
136 model.put("vnfTypeDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(VNFType.class)));
137 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
138 JSONObject j = new JSONObject(msg);
139 response.addHeader("successMapKey", "success");
140 response.addHeader("operation", "getDictionary");
141 response.getWriter().write(j.toString());
144 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
145 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
146 response.addHeader("error", "dictionaryDBQuery");
150 @RequestMapping(value={"/get_PEPOptionsDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
151 public void getPEPOptionsDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){
153 Map<String, Object> model = new HashMap<>();
154 ObjectMapper mapper = new ObjectMapper();
155 model.put("pepOptionsDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(PEPOptions.class, "pepName")));
156 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
157 JSONObject j = new JSONObject(msg);
158 response.getWriter().write(j.toString());
161 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
165 @RequestMapping(value={"/get_PEPOptionsData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
166 public void getPEPOptionsDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){
168 Map<String, Object> model = new HashMap<>();
169 ObjectMapper mapper = new ObjectMapper();
170 model.put("pepOptionsDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(PEPOptions.class)));
171 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
172 JSONObject j = new JSONObject(msg);
173 response.addHeader("successMapKey", "success");
174 response.addHeader("operation", "getDictionary");
175 response.getWriter().write(j.toString());
178 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
179 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
180 response.addHeader("error", "dictionaryDBQuery");
184 @RequestMapping(value={"/get_VarbindDictionaryDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
185 public void getVarbindDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){
187 Map<String, Object> model = new HashMap<>();
188 ObjectMapper mapper = new ObjectMapper();
189 model.put("varbindDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(VarbindDictionary.class, "varbindName")));
190 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
191 JSONObject j = new JSONObject(msg);
192 response.getWriter().write(j.toString());
195 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
199 @RequestMapping(value={"/get_VarbindDictionaryData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
200 public void getVarbindDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){
202 Map<String, Object> model = new HashMap<>();
203 ObjectMapper mapper = new ObjectMapper();
204 model.put("varbindDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(VarbindDictionary.class)));
205 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
206 JSONObject j = new JSONObject(msg);
207 response.addHeader("successMapKey", "success");
208 response.addHeader("operation", "getDictionary");
209 response.getWriter().write(j.toString());
212 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
213 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
214 response.addHeader("error", "dictionaryDBQuery");
218 @RequestMapping(value={"/get_ClosedLoopServicesDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
219 public void getClosedLoopServiceDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){
221 Map<String, Object> model = new HashMap<>();
222 ObjectMapper mapper = new ObjectMapper();
223 model.put("closedLoopServiceDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(ClosedLoopD2Services.class, "serviceName")));
224 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
225 JSONObject j = new JSONObject(msg);
226 response.getWriter().write(j.toString());
229 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
233 @RequestMapping(value={"/get_ClosedLoopServicesData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
234 public void getClosedLoopServiceDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){
236 Map<String, Object> model = new HashMap<>();
237 ObjectMapper mapper = new ObjectMapper();
238 model.put("closedLoopServiceDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(ClosedLoopD2Services.class)));
239 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
240 JSONObject j = new JSONObject(msg);
241 response.addHeader("successMapKey", "success");
242 response.addHeader("operation", "getDictionary");
243 response.getWriter().write(j.toString());
246 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
247 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
248 response.addHeader("error", "dictionaryDBQuery");
252 @RequestMapping(value={"/get_ClosedLoopSiteDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
253 public void getClosedLoopSiteDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){
255 Map<String, Object> model = new HashMap<>();
256 ObjectMapper mapper = new ObjectMapper();
257 model.put("closedLoopSiteDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(ClosedLoopSite.class, "siteName")));
258 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
259 JSONObject j = new JSONObject(msg);
260 response.getWriter().write(j.toString());
263 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
267 @RequestMapping(value={"/get_ClosedLoopSiteData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE)
268 public void getClosedLoopSiteDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){
270 Map<String, Object> model = new HashMap<>();
271 ObjectMapper mapper = new ObjectMapper();
272 model.put("closedLoopSiteDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(ClosedLoopSite.class)));
273 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
274 JSONObject j = new JSONObject(msg);
275 response.addHeader("successMapKey", "success");
276 response.addHeader("operation", "getDictionary");
277 response.getWriter().write(j.toString());
280 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
281 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
282 response.addHeader("error", "dictionaryDBQuery");
286 @RequestMapping(value={"/cl_dictionary/save_vsclAction"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
287 public ModelAndView saveVSCLAction(HttpServletRequest request, HttpServletResponse response)throws UnsupportedEncodingException, IOException{
289 boolean duplicateflag = false;
290 boolean isFakeUpdate = false;
291 boolean fromAPI = false;
292 if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) {
295 ObjectMapper mapper = new ObjectMapper();
296 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
297 JsonNode root = mapper.readTree(request.getReader());
298 VSCLAction vSCLAction;
299 String userId = null;
301 vSCLAction = (VSCLAction)mapper.readValue(root.get("dictionaryFields").toString(), VSCLAction.class);
304 //check if update operation or create, get id for data to be updated and update attributeData
305 if (request.getParameter("operation").equals("update")) {
306 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(vSCLAction.getVsclaction(), "vsclaction", VSCLAction.class);
308 VSCLAction data = (VSCLAction) duplicateData.get(0);
314 vSCLAction.setId(id);
317 vSCLAction.setUserCreatedBy(this.getUserInfo(userId));
321 vSCLAction = (VSCLAction)mapper.readValue(root.get("vsclActionDictionaryData").toString(), VSCLAction.class);
322 userId = root.get("userid").textValue();
324 if(vSCLAction.getId() == 0){
325 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(vSCLAction.getVsclaction(), "vsclaction", VSCLAction.class);
326 if(!duplicateData.isEmpty()){
327 duplicateflag = true;
329 vSCLAction.setUserCreatedBy(this.getUserInfo(userId));
330 vSCLAction.setUserModifiedBy(this.getUserInfo(userId));
331 vSCLAction.setModifiedDate(new Date());
332 commonClassDao.save(vSCLAction);
336 vSCLAction.setUserModifiedBy(this.getUserInfo(userId));
337 commonClassDao.update(vSCLAction);
341 String responseString = "";
343 responseString = "Duplicate";
345 responseString = mapper.writeValueAsString(commonClassDao.getData(VSCLAction.class));
348 if (responseString!=null && !responseString.equals("Duplicate")) {
350 responseString = "Exists";
352 responseString = "Success";
356 ModelAndView result = new ModelAndView();
357 result.setViewName(responseString);
360 response.setCharacterEncoding("UTF-8");
361 response.setContentType("application / json");
362 request.setCharacterEncoding("UTF-8");
364 PrintWriter out = response.getWriter();
365 JSONObject j = new JSONObject("{vsclActionDictionaryDatas: " + responseString + "}");
366 out.write(j.toString());
371 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
372 response.setCharacterEncoding("UTF-8");
373 request.setCharacterEncoding("UTF-8");
374 PrintWriter out = response.getWriter();
375 out.write(e.getMessage());
380 @RequestMapping(value={"/cl_dictionary/remove_VsclAction"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
381 public ModelAndView removeVSCLAction(HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException, IOException {
383 ObjectMapper mapper = new ObjectMapper();
384 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
385 JsonNode root = mapper.readTree(request.getReader());
386 VSCLAction vSCLAction = (VSCLAction)mapper.readValue(root.get("data").toString(), VSCLAction.class);
387 commonClassDao.delete(vSCLAction);
388 response.setCharacterEncoding("UTF-8");
389 response.setContentType("application / json");
390 request.setCharacterEncoding("UTF-8");
392 PrintWriter out = response.getWriter();
394 String responseString = mapper.writeValueAsString(commonClassDao.getData(VSCLAction.class));
395 JSONObject j = new JSONObject("{vsclActionDictionaryDatas: " + responseString + "}");
396 out.write(j.toString());
401 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
402 response.setCharacterEncoding("UTF-8");
403 request.setCharacterEncoding("UTF-8");
404 PrintWriter out = response.getWriter();
405 out.write(e.getMessage());
410 @RequestMapping(value={"/cl_dictionary/save_vnfType"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
411 public ModelAndView saveVnfType(HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException, IOException{
413 boolean duplicateflag = false;
414 boolean isFakeUpdate = false;
415 boolean fromAPI = false;
417 if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) {
420 ObjectMapper mapper = new ObjectMapper();
421 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
422 JsonNode root = mapper.readTree(request.getReader());
424 String userId = null;
427 vNFType = (VNFType)mapper.readValue(root.get("dictionaryFields").toString(), VNFType.class);
430 //check if update operation or create, get id for data to be updated and update attributeData
431 if (request.getParameter("operation").equals("update")) {
432 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(vNFType.getVnftype(), "vnftype", VNFType.class);
434 VNFType data = (VNFType) duplicateData.get(0);
442 vNFType.setUserCreatedBy(this.getUserInfo(userId));
445 vNFType = (VNFType)mapper.readValue(root.get("vnfTypeDictionaryData").toString(), VNFType.class);
446 userId = root.get("userid").textValue();
448 if(vNFType.getId() == 0){
449 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(vNFType.getVnftype(), "vnftype", VNFType.class);
450 if(!duplicateData.isEmpty()){
451 duplicateflag = true;
453 vNFType.setUserCreatedBy(this.getUserInfo(userId));
454 vNFType.setUserModifiedBy(this.getUserInfo(userId));
455 commonClassDao.save(vNFType);
459 vNFType.setUserModifiedBy(this.getUserInfo(userId));
460 vNFType.setModifiedDate(new Date());
461 commonClassDao.update(vNFType);
464 String responseString = "";
466 responseString = "Duplicate";
468 responseString = mapper.writeValueAsString(commonClassDao.getData(VNFType.class));
471 if (responseString!=null && !responseString.equals("Duplicate")) {
473 responseString = "Exists";
475 responseString = "Success";
478 ModelAndView result = new ModelAndView();
479 result.setViewName(responseString);
482 response.setCharacterEncoding("UTF-8");
483 response.setContentType("application / json");
484 request.setCharacterEncoding("UTF-8");
486 PrintWriter out = response.getWriter();
487 JSONObject j = new JSONObject("{vnfTypeDictionaryDatas: " + responseString + "}");
488 out.write(j.toString());
493 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
494 response.setCharacterEncoding("UTF-8");
495 request.setCharacterEncoding("UTF-8");
496 PrintWriter out = response.getWriter();
497 out.write(e.getMessage());
502 @RequestMapping(value={"/cl_dictionary/remove_vnfType"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
503 public ModelAndView removeVnfType(HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException, IOException {
505 ObjectMapper mapper = new ObjectMapper();
506 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
507 JsonNode root = mapper.readTree(request.getReader());
508 VNFType vNFType = (VNFType)mapper.readValue(root.get("data").toString(), VNFType.class);
509 commonClassDao.delete(vNFType);
510 response.setCharacterEncoding("UTF-8");
511 response.setContentType("application / json");
512 request.setCharacterEncoding("UTF-8");
514 PrintWriter out = response.getWriter();
516 String responseString = mapper.writeValueAsString(commonClassDao.getData(VNFType.class));
517 JSONObject j = new JSONObject("{vnfTypeDictionaryDatas: " + responseString + "}");
518 out.write(j.toString());
523 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
524 response.setCharacterEncoding("UTF-8");
525 request.setCharacterEncoding("UTF-8");
526 PrintWriter out = response.getWriter();
527 out.write(e.getMessage());
532 @RequestMapping(value={"/cl_dictionary/save_pepOptions"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
533 public ModelAndView savePEPOptions(HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException, IOException{
535 boolean duplicateflag = false;
536 boolean isFakeUpdate = false;
537 boolean fromAPI = false;
538 if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) {
541 ObjectMapper mapper = new ObjectMapper();
542 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
543 JsonNode root = mapper.readTree(request.getReader());
544 PEPOptions pEPOptions;
546 String userId = null;
548 pEPOptions = (PEPOptions)mapper.readValue(root.get("dictionaryFields").toString(), PEPOptions.class);
549 gridData = (GridData)mapper.readValue(root.get("dictionaryFields").toString(), GridData.class);
552 //check if update operation or create, get id for data to be updated and update attributeData
553 if (request.getParameter("operation").equals("update")) {
554 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(pEPOptions.getPepName(), "pepName", PEPOptions.class);
556 PEPOptions data = (PEPOptions) duplicateData.get(0);
562 pEPOptions.setId(id);
564 pEPOptions.setUserCreatedBy(this.getUserInfo(userId));
567 pEPOptions = (PEPOptions)mapper.readValue(root.get("pepOptionsDictionaryData").toString(), PEPOptions.class);
568 gridData = (GridData)mapper.readValue(root.get("pepOptionsDictionaryData").toString(), GridData.class);
569 userId = root.get("userid").textValue();
573 if(gridData.getAttributes().size() > 0){
574 for(Object attribute : gridData.getAttributes()){
575 if(attribute instanceof LinkedHashMap<?, ?>){
576 String key = ((LinkedHashMap<?, ?>) attribute).get("option").toString();
577 String value = ((LinkedHashMap<?, ?>) attribute).get("number").toString();
579 actions = actions + ":#@";
581 actions = actions + key + "=#@";
582 actions = actions + value;
587 pEPOptions.setActions(actions);
588 if(pEPOptions.getId() == 0){
589 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(pEPOptions.getPepName(), "pepName", PEPOptions.class);
590 if(!duplicateData.isEmpty()){
591 duplicateflag = true;
593 pEPOptions.setUserCreatedBy(this.getUserInfo(userId));
594 pEPOptions.setUserModifiedBy(this.getUserInfo(userId));
595 commonClassDao.save(pEPOptions);
599 pEPOptions.setUserModifiedBy(this.getUserInfo(userId));
600 pEPOptions.setModifiedDate(new Date());
601 commonClassDao.update(pEPOptions);
604 String responseString = "";
606 responseString = "Duplicate";
608 responseString = mapper.writeValueAsString(commonClassDao.getData(PEPOptions.class));
611 if (responseString!=null && !responseString.equals("Duplicate")) {
613 responseString = "Exists";
615 responseString = "Success";
619 ModelAndView result = new ModelAndView();
620 result.setViewName(responseString);
623 response.setCharacterEncoding("UTF-8");
624 response.setContentType("application / json");
625 request.setCharacterEncoding("UTF-8");
627 PrintWriter out = response.getWriter();
628 JSONObject j = new JSONObject("{pepOptionsDictionaryDatas: " + responseString + "}");
629 out.write(j.toString());
633 }catch (Exception e){
634 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
635 response.setCharacterEncoding("UTF-8");
636 request.setCharacterEncoding("UTF-8");
637 PrintWriter out = response.getWriter();
638 out.write(e.getMessage());
643 @RequestMapping(value={"/cl_dictionary/remove_pepOptions"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
644 public ModelAndView removePEPOptions(HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException, IOException {
646 ObjectMapper mapper = new ObjectMapper();
647 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
648 JsonNode root = mapper.readTree(request.getReader());
649 PEPOptions pEPOptions = (PEPOptions)mapper.readValue(root.get("data").toString(), PEPOptions.class);
650 commonClassDao.delete(pEPOptions);
651 response.setCharacterEncoding("UTF-8");
652 response.setContentType("application / json");
653 request.setCharacterEncoding("UTF-8");
655 PrintWriter out = response.getWriter();
657 String responseString = mapper.writeValueAsString(commonClassDao.getData(PEPOptions.class));
658 JSONObject j = new JSONObject("{pepOptionsDictionaryDatas: " + responseString + "}");
659 out.write(j.toString());
664 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
665 response.setCharacterEncoding("UTF-8");
666 request.setCharacterEncoding("UTF-8");
667 PrintWriter out = response.getWriter();
668 out.write(e.getMessage());
673 @RequestMapping(value={"/cl_dictionary/save_service"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
674 public ModelAndView saveServiceType(HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException, IOException{
676 boolean duplicateflag = false;
677 boolean isFakeUpdate = false;
678 boolean fromAPI = false;
679 if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) {
682 ObjectMapper mapper = new ObjectMapper();
683 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
684 JsonNode root = mapper.readTree(request.getReader());
685 ClosedLoopD2Services serviceData;
686 String userId = null;
688 serviceData = (ClosedLoopD2Services)mapper.readValue(root.get("dictionaryFields").toString(), ClosedLoopD2Services.class);
691 //check if update operation or create, get id for data to be updated and update attributeData
692 if (request.getParameter("operation").equals("update")) {
693 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(serviceData.getServiceName(), "serviceName", ClosedLoopD2Services.class);
695 ClosedLoopD2Services data = (ClosedLoopD2Services) duplicateData.get(0);
699 serviceData.setId(1);
701 serviceData.setId(id);
703 serviceData.setUserCreatedBy(this.getUserInfo(userId));
706 serviceData = (ClosedLoopD2Services)mapper.readValue(root.get("closedLoopServiceDictionaryData").toString(), ClosedLoopD2Services.class);
707 userId = root.get("userid").textValue();
709 if(serviceData.getId() == 0){
710 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(serviceData.getServiceName(), "serviceName", ClosedLoopD2Services.class);
711 if(!duplicateData.isEmpty()){
712 duplicateflag = true;
714 serviceData.setUserCreatedBy(this.getUserInfo(userId));
715 serviceData.setUserModifiedBy(this.getUserInfo(userId));
716 commonClassDao.save(serviceData);
720 serviceData.setUserModifiedBy(this.getUserInfo(userId));
721 serviceData.setModifiedDate(new Date());
722 commonClassDao.update(serviceData);
725 String responseString = "";
727 responseString = "Duplicate";
729 responseString = mapper.writeValueAsString(commonClassDao.getData(ClosedLoopD2Services.class));
732 if (responseString!=null && !responseString.equals("Duplicate")) {
734 responseString = "Exists";
736 responseString = "Success";
739 ModelAndView result = new ModelAndView();
740 result.setViewName(responseString);
743 response.setCharacterEncoding("UTF-8");
744 response.setContentType("application / json");
745 request.setCharacterEncoding("UTF-8");
747 PrintWriter out = response.getWriter();
748 JSONObject j = new JSONObject("{closedLoopServiceDictionaryDatas: " + responseString + "}");
749 out.write(j.toString());
752 }catch (Exception e){
753 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
754 response.setCharacterEncoding("UTF-8");
755 request.setCharacterEncoding("UTF-8");
756 PrintWriter out = response.getWriter();
757 out.write(e.getMessage());
762 @RequestMapping(value={"/cl_dictionary/remove_Service"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
763 public ModelAndView removeServiceType(HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException, IOException {
765 ObjectMapper mapper = new ObjectMapper();
766 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
767 JsonNode root = mapper.readTree(request.getReader());
768 ClosedLoopD2Services closedLoopD2Services = (ClosedLoopD2Services)mapper.readValue(root.get("data").toString(), ClosedLoopD2Services.class);
769 commonClassDao.delete(closedLoopD2Services);
770 response.setCharacterEncoding("UTF-8");
771 response.setContentType("application / json");
772 request.setCharacterEncoding("UTF-8");
774 PrintWriter out = response.getWriter();
776 String responseString = mapper.writeValueAsString(commonClassDao.getData(ClosedLoopD2Services.class));
777 JSONObject j = new JSONObject("{closedLoopServiceDictionaryDatas: " + responseString + "}");
778 out.write(j.toString());
783 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
784 response.setCharacterEncoding("UTF-8");
785 request.setCharacterEncoding("UTF-8");
786 PrintWriter out = response.getWriter();
787 out.write(e.getMessage());
792 @RequestMapping(value={"/cl_dictionary/save_siteName"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
793 public ModelAndView saveSiteType(HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException, IOException{
795 boolean duplicateflag = false;
796 boolean isFakeUpdate = false;
797 boolean fromAPI = false;
799 if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) {
802 ObjectMapper mapper = new ObjectMapper();
803 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
804 JsonNode root = mapper.readTree(request.getReader());
805 ClosedLoopSite siteData;
806 String userId = null;
808 siteData = (ClosedLoopSite)mapper.readValue(root.get("dictionaryFields").toString(), ClosedLoopSite.class);
810 //check if update operation or create, get id for data to be updated and update attributeData
811 if (request.getParameter("operation").equals("update")) {
812 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(siteData.getSiteName(), "siteName", ClosedLoopSite.class);
814 ClosedLoopSite data = (ClosedLoopSite) duplicateData.get(0);
822 siteData.setUserCreatedBy(this.getUserInfo(userId));
825 siteData = (ClosedLoopSite)mapper.readValue(root.get("closedLoopSiteDictionaryData").toString(), ClosedLoopSite.class);
826 userId = root.get("userid").textValue();
828 if(siteData.getId() == 0){
829 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(siteData.getSiteName(), "siteName", ClosedLoopSite.class);
830 if(!duplicateData.isEmpty()){
831 duplicateflag = true;
833 siteData.setUserCreatedBy(this.getUserInfo(userId));
834 siteData.setUserModifiedBy(this.getUserInfo(userId));
835 commonClassDao.save(siteData);
839 siteData.setUserModifiedBy(this.getUserInfo(userId));
840 siteData.setModifiedDate(new Date());
841 commonClassDao.update(siteData);
844 String responseString = "";
846 responseString = "Duplicate";
848 responseString = mapper.writeValueAsString(commonClassDao.getData(ClosedLoopSite.class));
852 if (responseString!=null && !responseString.equals("Duplicate")) {
854 responseString = "Exists";
856 responseString = "Success";
859 ModelAndView result = new ModelAndView();
860 result.setViewName(responseString);
863 response.setCharacterEncoding("UTF-8");
864 response.setContentType("application / json");
865 request.setCharacterEncoding("UTF-8");
867 PrintWriter out = response.getWriter();
868 JSONObject j = new JSONObject("{closedLoopSiteDictionaryDatas: " + responseString + "}");
869 out.write(j.toString());
872 }catch (Exception e){
873 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
874 response.setCharacterEncoding("UTF-8");
875 request.setCharacterEncoding("UTF-8");
876 PrintWriter out = response.getWriter();
877 out.write(e.getMessage());
882 @RequestMapping(value={"/cl_dictionary/remove_site"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
883 public ModelAndView removeSiteType(HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException, IOException {
885 ObjectMapper mapper = new ObjectMapper();
886 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
887 JsonNode root = mapper.readTree(request.getReader());
888 ClosedLoopSite closedLoopSite = (ClosedLoopSite)mapper.readValue(root.get("data").toString(), ClosedLoopSite.class);
889 commonClassDao.delete(closedLoopSite);
890 response.setCharacterEncoding("UTF-8");
891 response.setContentType("application / json");
892 request.setCharacterEncoding("UTF-8");
894 PrintWriter out = response.getWriter();
896 String responseString = mapper.writeValueAsString(commonClassDao.getData(ClosedLoopSite.class));
897 JSONObject j = new JSONObject("{closedLoopSiteDictionaryDatas: " + responseString + "}");
898 out.write(j.toString());
903 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
904 response.setCharacterEncoding("UTF-8");
905 request.setCharacterEncoding("UTF-8");
906 PrintWriter out = response.getWriter();
907 out.write(e.getMessage());
912 @RequestMapping(value={"/cl_dictionary/save_varbind"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
913 public ModelAndView saveVarbind(HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException, IOException{
915 boolean duplicateflag = false;
916 boolean isFakeUpdate = false;
917 boolean fromAPI = false;
918 if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) {
921 ObjectMapper mapper = new ObjectMapper();
922 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
923 JsonNode root = mapper.readTree(request.getReader());
924 VarbindDictionary varbindDictionary;
925 String userId = null;
927 varbindDictionary = (VarbindDictionary)mapper.readValue(root.get("dictionaryFields").toString(), VarbindDictionary.class);
930 //check if update operation or create, get id for data to be updated and update attributeData
931 if (request.getParameter("operation").equals("update")) {
932 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(varbindDictionary.getVarbindName(), "varbindName", VarbindDictionary.class);
934 VarbindDictionary data = (VarbindDictionary) duplicateData.get(0);
938 varbindDictionary.setId(1);
940 varbindDictionary.setId(id);
942 varbindDictionary.setUserCreatedBy(this.getUserInfo(userId));
945 varbindDictionary = (VarbindDictionary)mapper.readValue(root.get("varbindDictionaryData").toString(), VarbindDictionary.class);
946 userId = root.get("userid").textValue();
948 if(varbindDictionary.getId() == 0){
949 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(varbindDictionary.getVarbindName(), "varbindName", VarbindDictionary.class);
950 if(!duplicateData.isEmpty()){
951 duplicateflag = true;
953 varbindDictionary.setUserCreatedBy(this.getUserInfo(userId));
954 varbindDictionary.setUserModifiedBy(this.getUserInfo(userId));
955 commonClassDao.save(varbindDictionary);
959 varbindDictionary.setUserModifiedBy(this.getUserInfo(userId));
960 varbindDictionary.setModifiedDate(new Date());
961 commonClassDao.update(varbindDictionary);
964 String responseString = "";
966 responseString = "Duplicate";
968 responseString = mapper.writeValueAsString(commonClassDao.getData(VarbindDictionary.class));
972 if (responseString!=null && !responseString.equals("Duplicate")) {
974 responseString = "Exists";
976 responseString = "Success";
979 ModelAndView result = new ModelAndView();
980 result.setViewName(responseString);
983 response.setCharacterEncoding("UTF-8");
984 response.setContentType("application / json");
985 request.setCharacterEncoding("UTF-8");
987 PrintWriter out = response.getWriter();
988 JSONObject j = new JSONObject("{varbindDictionaryDatas: " + responseString + "}");
989 out.write(j.toString());
992 }catch (Exception e){
993 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
994 response.setCharacterEncoding("UTF-8");
995 request.setCharacterEncoding("UTF-8");
996 PrintWriter out = response.getWriter();
997 out.write(e.getMessage());
1002 @RequestMapping(value={"/cl_dictionary/remove_varbindDict"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
1003 public ModelAndView removeVarbind(HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException, IOException{
1005 ObjectMapper mapper = new ObjectMapper();
1006 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
1007 JsonNode root = mapper.readTree(request.getReader());
1008 VarbindDictionary varbindDictionary = (VarbindDictionary)mapper.readValue(root.get("data").toString(), VarbindDictionary.class);
1009 commonClassDao.delete(varbindDictionary);
1010 response.setCharacterEncoding("UTF-8");
1011 response.setContentType("application / json");
1012 request.setCharacterEncoding("UTF-8");
1014 PrintWriter out = response.getWriter();
1016 String responseString = mapper.writeValueAsString(commonClassDao.getData(VarbindDictionary.class));
1017 JSONObject j = new JSONObject("{varbindDictionaryDatas: " + responseString + "}");
1018 out.write(j.toString());
1022 catch (Exception e){
1023 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e);
1024 response.setCharacterEncoding("UTF-8");
1025 request.setCharacterEncoding("UTF-8");
1026 PrintWriter out = response.getWriter();
1027 out.write(e.getMessage());