2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017-2019 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 com.fasterxml.jackson.databind.DeserializationFeature;
24 import com.fasterxml.jackson.databind.JsonNode;
25 import com.fasterxml.jackson.databind.ObjectMapper;
26 import com.google.gson.Gson;
28 import java.io.IOException;
29 import java.util.ArrayList;
30 import java.util.Arrays;
31 import java.util.HashMap;
32 import java.util.LinkedHashMap;
33 import java.util.List;
37 import javax.servlet.http.HttpServletRequest;
38 import javax.servlet.http.HttpServletResponse;
40 import org.apache.commons.lang.StringUtils;
41 import org.json.JSONObject;
42 import org.onap.policy.common.logging.flexlogger.FlexLogger;
43 import org.onap.policy.common.logging.flexlogger.Logger;
44 import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
45 import org.onap.policy.pap.xacml.rest.util.DictionaryUtils;
46 import org.onap.policy.pap.xacml.rest.util.JsonMessage;
47 import org.onap.policy.rest.dao.CommonClassDao;
48 import org.onap.policy.rest.jpa.DcaeUuid;
49 import org.onap.policy.rest.jpa.DictionaryData;
50 import org.onap.policy.rest.jpa.MicroServiceAttribute;
51 import org.onap.policy.rest.jpa.MicroServiceConfigName;
52 import org.onap.policy.rest.jpa.MicroServiceLocation;
53 import org.onap.policy.rest.jpa.MicroServiceModels;
54 import org.onap.policy.rest.jpa.MicroserviceHeaderdeFaults;
55 import org.onap.policy.rest.jpa.PrefixList;
56 import org.onap.policy.rest.jpa.UserInfo;
57 import org.onap.policy.rest.util.MSAttributeObject;
58 import org.onap.policy.rest.util.MSModelUtils;
59 import org.springframework.beans.factory.annotation.Autowired;
60 import org.springframework.http.MediaType;
61 import org.springframework.stereotype.Controller;
62 import org.springframework.web.bind.annotation.RequestMapping;
63 import org.springframework.web.bind.annotation.RequestMethod;
64 import org.springframework.web.servlet.ModelAndView;
67 public class MicroServiceDictionaryController {
68 private static final Logger LOGGER = FlexLogger.getLogger(MicroServiceDictionaryController.class);
70 private static CommonClassDao commonClassDao;
72 private static String successMapKey = "successMapKey";
73 private static String successMsg = "success";
74 private static String operation = "operation";
75 private static String getDictionary = "getDictionary";
76 private static String errorMsg = "error";
77 private static String dictionaryDBQuery = "dictionaryDBQuery";
78 private LinkedHashMap<String, MSAttributeObject> classMap;
79 private List<String> modelList = new ArrayList<>();
80 private static String dictionaryFields = "dictionaryFields";
81 private static String duplicateResponseString = "Duplicate";
82 private static String microServiceModelsDictionaryDatas = "microServiceModelsDictionaryDatas";
83 private static String modelName = "modelName";
84 private static String microServiceModelsDictionaryData = "microServiceModelsDictionaryData";
85 private static String description = "description";
86 private static String version = "version";
87 private static String classMapData = "classMap";
88 private static String dcaeUUIDDatas = "dcaeUUIDDictionaryDatas";
89 private static String microServiceConfigNameDatas = "microServiceConfigNameDictionaryDatas";
90 private static String microServiceLocationDatas = "microServiceLocationDictionaryDatas";
91 private static String microServiceAttributeDatas = "microServiceAttributeDictionaryDatas";
92 private static String microServiceHeaderDefaultDatas = "microServiceHeaderDefaultDatas";
93 private static final String MICROSERVICEDICTNAMEDATAS = "microServiceDictionaryDatas";
95 public MicroServiceDictionaryController() {
99 private DictionaryUtils getDictionaryUtilsInstance() {
100 return DictionaryUtils.getDictionaryUtils();
104 public MicroServiceDictionaryController(CommonClassDao commonClassDao) {
105 MicroServiceDictionaryController.commonClassDao = commonClassDao;
108 public static void setCommonClassDao(CommonClassDao commonClassDao) {
109 MicroServiceDictionaryController.commonClassDao = commonClassDao;
112 MSModelUtils utils = new MSModelUtils(XACMLPapServlet.getMsOnapName(), XACMLPapServlet.getMsPolicyName());
114 private MicroServiceModels newModel;
117 value = {"/get_DCAEUUIDDataByName"},
118 method = {RequestMethod.GET},
119 produces = MediaType.APPLICATION_JSON_VALUE)
120 public void getDCAEUUIDDictionaryByNameEntityData(HttpServletResponse response) {
121 DictionaryUtils utils = getDictionaryUtilsInstance();
122 utils.getDataByEntity(response, dcaeUUIDDatas, "name", DcaeUuid.class);
126 value = {"/get_DCAEUUIDData"},
127 method = {RequestMethod.GET},
128 produces = MediaType.APPLICATION_JSON_VALUE)
129 public void getDCAEUUIDDictionaryEntityData(HttpServletResponse response) {
130 DictionaryUtils utils = getDictionaryUtilsInstance();
131 utils.getData(response, dcaeUUIDDatas, DcaeUuid.class);
134 @RequestMapping(value = {"/ms_dictionary/save_dcaeUUID"}, method = {RequestMethod.POST})
135 public ModelAndView saveDCAEUUIDDictionary(HttpServletRequest request, HttpServletResponse response)
137 DictionaryUtils utils = getDictionaryUtilsInstance();
139 boolean fromAPI = utils.isRequestFromAPI(request);
140 ObjectMapper mapper = new ObjectMapper();
141 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
142 JsonNode root = mapper.readTree(request.getReader());
145 dCAEuuid = mapper.readValue(root.get(dictionaryFields).toString(), DcaeUuid.class);
147 dCAEuuid = mapper.readValue(root.get("dcaeUUIDDictionaryData").toString(), DcaeUuid.class);
150 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(dCAEuuid.getName(), "name", DcaeUuid.class);
151 boolean duplicateflag = false;
152 if (duplicateData != null && !duplicateData.isEmpty()) {
153 DcaeUuid data = (DcaeUuid) duplicateData.get(0);
154 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
155 dCAEuuid.setId(data.getId());
156 } else if ((request.getParameter(operation) != null
157 && !"update".equals(request.getParameter(operation)))
158 || (request.getParameter(operation) == null && (data.getId() != dCAEuuid.getId()))) {
159 duplicateflag = true;
162 String responseString = null;
163 if (!duplicateflag) {
164 if (dCAEuuid.getId() == 0) {
165 commonClassDao.save(dCAEuuid);
167 commonClassDao.update(dCAEuuid);
169 responseString = mapper.writeValueAsString(commonClassDao.getData(DcaeUuid.class));
171 responseString = duplicateResponseString;
174 return utils.getResultForApi(responseString);
176 utils.setResponseData(response, dcaeUUIDDatas, responseString);
178 } catch (Exception e) {
179 utils.setErrorResponseData(response, e);
184 @RequestMapping(value = {"/ms_dictionary/remove_dcaeuuid"}, method = {RequestMethod.POST})
185 public void removeDCAEUUIDDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException {
186 DictionaryUtils utils = getDictionaryUtilsInstance();
187 utils.removeData(request, response, dcaeUUIDDatas, DcaeUuid.class);
191 value = {"/get_MicroServiceConfigNameDataByName"},
192 method = {RequestMethod.GET},
193 produces = MediaType.APPLICATION_JSON_VALUE)
194 public void getMicroServiceConfigNameByNameDictionaryEntityData(HttpServletResponse response) {
195 DictionaryUtils utils = getDictionaryUtilsInstance();
196 utils.getDataByEntity(response, microServiceConfigNameDatas, "name", MicroServiceConfigName.class);
200 value = {"/get_MicroServiceConfigNameData"},
201 method = {RequestMethod.GET},
202 produces = MediaType.APPLICATION_JSON_VALUE)
203 public void getMicroServiceConfigNameDictionaryEntityData(HttpServletResponse response) {
204 DictionaryUtils utils = getDictionaryUtilsInstance();
205 utils.getData(response, microServiceConfigNameDatas, MicroServiceConfigName.class);
209 value = {"/get_MicroServiceDictData"},
210 method = {RequestMethod.GET},
211 produces = MediaType.APPLICATION_JSON_VALUE)
212 public void getMicroServiceDictNameDictionaryEntityData(HttpServletResponse response) {
213 DictionaryUtils utils = getDictionaryUtilsInstance();
214 utils.getData(response, MICROSERVICEDICTNAMEDATAS, DictionaryData.class);
218 * Save dictionary data.
220 * @param request the request
221 * @param response the response
222 * @return the model and view
223 * @throws IOException Signals that an I/O exception has occurred.
225 // save_DictionaryData
226 @RequestMapping(value = {"/ms_dictionary/save_DictionaryData"}, method = {RequestMethod.POST})
227 public ModelAndView saveDictionaryData(HttpServletRequest request, HttpServletResponse response)
229 DictionaryUtils dictUtil = getDictionaryUtilsInstance();
231 boolean fromApi = dictUtil.isRequestFromAPI(request);
232 ObjectMapper mapper = new ObjectMapper();
233 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
234 JsonNode root = mapper.readTree(request.getReader());
235 DictionaryData dictionaryData;
237 dictionaryData = mapper.readValue(root.get(dictionaryFields).toString(), DictionaryData.class);
239 dictionaryData = mapper.readValue(root.get(MICROSERVICEDICTNAMEDATAS).toString(), DictionaryData.class);
241 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(dictionaryData.getDictionaryName(),
242 "dictionaryName", DictionaryData.class);
243 boolean duplicateflag = false;
244 if (duplicateData != null && !duplicateData.isEmpty()) {
245 DictionaryData data = (DictionaryData) duplicateData.get(0);
246 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
247 dictionaryData.setId(data.getId());
248 } else if ((request.getParameter(operation) != null
249 && !"update".equals(request.getParameter(operation)))
250 || (request.getParameter(operation) == null && (data.getId() != dictionaryData.getId()))) {
251 duplicateflag = true;
254 String responseString = null;
255 if (!duplicateflag) {
256 if (dictionaryData.getId() == 0) {
257 commonClassDao.save(dictionaryData);
259 commonClassDao.update(dictionaryData);
261 responseString = mapper.writeValueAsString(commonClassDao.getData(DictionaryData.class));
263 responseString = duplicateResponseString;
266 return dictUtil.getResultForApi(responseString);
268 dictUtil.setResponseData(response, MICROSERVICEDICTNAMEDATAS, responseString);
270 } catch (Exception e) {
271 dictUtil.setErrorResponseData(response, e);
276 @RequestMapping(value = {"/ms_dictionary/remove_msDictionaryData"}, method = {RequestMethod.POST})
277 public void removeMicroServiceDictionaryData(HttpServletRequest request, HttpServletResponse response)
279 DictionaryUtils utils = getDictionaryUtilsInstance();
280 utils.removeData(request, response, MICROSERVICEDICTNAMEDATAS, DictionaryData.class);
284 @RequestMapping(value = {"/ms_dictionary/save_configName"}, method = {RequestMethod.POST})
285 public ModelAndView saveMicroServiceConfigNameDictionary(HttpServletRequest request, HttpServletResponse response)
287 DictionaryUtils utils = getDictionaryUtilsInstance();
289 boolean fromAPI = utils.isRequestFromAPI(request);
290 ObjectMapper mapper = new ObjectMapper();
291 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
292 JsonNode root = mapper.readTree(request.getReader());
293 MicroServiceConfigName microServiceConfigName;
295 microServiceConfigName =
296 mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceConfigName.class);
298 microServiceConfigName = mapper.readValue(root.get("microServiceConfigNameDictionaryData").toString(),
299 MicroServiceConfigName.class);
301 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(microServiceConfigName.getName(), "name",
302 MicroServiceConfigName.class);
303 boolean duplicateflag = false;
304 if (duplicateData != null && !duplicateData.isEmpty()) {
305 MicroServiceConfigName data = (MicroServiceConfigName) duplicateData.get(0);
306 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
307 microServiceConfigName.setId(data.getId());
308 } else if ((request.getParameter(operation) != null
309 && !"update".equals(request.getParameter(operation)))
310 || (request.getParameter(operation) == null
311 && (data.getId() != microServiceConfigName.getId()))) {
312 duplicateflag = true;
315 String responseString = null;
316 if (!duplicateflag) {
317 if (microServiceConfigName.getId() == 0) {
318 commonClassDao.save(microServiceConfigName);
320 commonClassDao.update(microServiceConfigName);
322 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceConfigName.class));
324 responseString = duplicateResponseString;
327 return utils.getResultForApi(responseString);
329 utils.setResponseData(response, microServiceConfigNameDatas, responseString);
331 } catch (Exception e) {
332 utils.setErrorResponseData(response, e);
337 @RequestMapping(value = {"/ms_dictionary/remove_msConfigName"}, method = {RequestMethod.POST})
338 public void removeMicroServiceConfigNameDictionary(HttpServletRequest request, HttpServletResponse response)
340 DictionaryUtils utils = getDictionaryUtilsInstance();
341 utils.removeData(request, response, microServiceConfigNameDatas, MicroServiceConfigName.class);
345 value = {"/get_MicroServiceLocationDataByName"},
346 method = {RequestMethod.GET},
347 produces = MediaType.APPLICATION_JSON_VALUE)
348 public void getMicroServiceLocationByNameDictionaryEntityData(HttpServletResponse response) {
349 DictionaryUtils utils = getDictionaryUtilsInstance();
350 utils.getDataByEntity(response, microServiceLocationDatas, "name", MicroServiceLocation.class);
354 value = {"/get_MicroServiceLocationData"},
355 method = {RequestMethod.GET},
356 produces = MediaType.APPLICATION_JSON_VALUE)
357 public void getMicroServiceLocationDictionaryEntityData(HttpServletResponse response) {
358 DictionaryUtils utils = getDictionaryUtilsInstance();
359 utils.getData(response, microServiceLocationDatas, MicroServiceLocation.class);
362 @RequestMapping(value = {"/ms_dictionary/save_location"}, method = {RequestMethod.POST})
363 public ModelAndView saveMicroServiceLocationDictionary(HttpServletRequest request, HttpServletResponse response)
365 DictionaryUtils utils = getDictionaryUtilsInstance();
367 boolean fromAPI = utils.isRequestFromAPI(request);
368 ObjectMapper mapper = new ObjectMapper();
369 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
370 JsonNode root = mapper.readTree(request.getReader());
371 MicroServiceLocation microServiceLocation;
373 microServiceLocation =
374 mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceLocation.class);
376 microServiceLocation = mapper.readValue(root.get("microServiceLocationDictionaryData").toString(),
377 MicroServiceLocation.class);
380 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(microServiceLocation.getName(), "name",
381 MicroServiceLocation.class);
382 boolean duplicateflag = false;
383 if (duplicateData != null && !duplicateData.isEmpty()) {
384 MicroServiceLocation data = (MicroServiceLocation) duplicateData.get(0);
385 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
386 microServiceLocation.setId(data.getId());
387 } else if ((request.getParameter(operation) != null
388 && !"update".equals(request.getParameter(operation)))
389 || (request.getParameter(operation) == null
390 && (data.getId() != microServiceLocation.getId()))) {
391 duplicateflag = true;
394 String responseString = null;
395 if (!duplicateflag) {
396 if (microServiceLocation.getId() == 0) {
397 commonClassDao.save(microServiceLocation);
399 commonClassDao.update(microServiceLocation);
401 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceLocation.class));
403 responseString = duplicateResponseString;
406 return utils.getResultForApi(responseString);
408 utils.setResponseData(response, microServiceLocationDatas, responseString);
410 } catch (Exception e) {
411 utils.setErrorResponseData(response, e);
416 @RequestMapping(value = {"/ms_dictionary/remove_msLocation"}, method = {RequestMethod.POST})
417 public void removeMicroServiceLocationDictionary(HttpServletRequest request, HttpServletResponse response)
419 DictionaryUtils utils = getDictionaryUtilsInstance();
420 utils.removeData(request, response, microServiceLocationDatas, MicroServiceLocation.class);
424 value = {"/get_MicroServiceAttributeDataByName"},
425 method = {RequestMethod.GET},
426 produces = MediaType.APPLICATION_JSON_VALUE)
427 public void getMicroServiceAttributeByNameDictionaryEntityData(HttpServletResponse response) {
428 DictionaryUtils utils = getDictionaryUtilsInstance();
429 utils.getDataByEntity(response, microServiceAttributeDatas, "name", MicroServiceAttribute.class);
433 value = {"/get_MicroServiceAttributeData"},
434 method = {RequestMethod.GET},
435 produces = MediaType.APPLICATION_JSON_VALUE)
436 public void getMicroServiceAttributeDictionaryEntityData(HttpServletResponse response) {
437 DictionaryUtils utils = getDictionaryUtilsInstance();
438 utils.getData(response, microServiceAttributeDatas, MicroServiceAttribute.class);
441 @RequestMapping(value = {"/ms_dictionary/save_modelAttribute"}, method = {RequestMethod.POST})
442 public ModelAndView saveMicroServiceAttributeDictionary(HttpServletRequest request, HttpServletResponse response)
444 DictionaryUtils utils = getDictionaryUtilsInstance();
446 boolean fromAPI = utils.isRequestFromAPI(request);
447 ObjectMapper mapper = new ObjectMapper();
448 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
449 JsonNode root = mapper.readTree(request.getReader());
451 MicroServiceAttribute microServiceAttribute;
454 microServiceAttribute =
455 mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceAttribute.class);
457 microServiceAttribute = mapper.readValue(root.get("modelAttributeDictionaryData").toString(),
458 MicroServiceAttribute.class);
460 checkValue = microServiceAttribute.getName() + ":" + microServiceAttribute.getValue() + ":"
461 + microServiceAttribute.getModelName();
462 List<Object> duplicateData =
463 commonClassDao.checkDuplicateEntry(checkValue, "name:value:modelName", MicroServiceAttribute.class);
464 boolean duplicateflag = false;
465 if (duplicateData != null && !duplicateData.isEmpty()) {
466 MicroServiceAttribute data = (MicroServiceAttribute) duplicateData.get(0);
467 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
468 microServiceAttribute.setId(data.getId());
469 } else if ((request.getParameter(operation) != null
470 && !"update".equals(request.getParameter(operation)))
471 || (request.getParameter(operation) == null
472 && (data.getId() != microServiceAttribute.getId()))) {
473 duplicateflag = true;
476 String responseString = null;
477 if (!duplicateflag) {
478 if (microServiceAttribute.getId() == 0) {
479 commonClassDao.save(microServiceAttribute);
481 commonClassDao.update(microServiceAttribute);
483 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceAttribute.class));
485 responseString = duplicateResponseString;
488 return utils.getResultForApi(responseString);
490 utils.setResponseData(response, microServiceAttributeDatas, responseString);
492 } catch (Exception e) {
493 utils.setErrorResponseData(response, e);
498 @RequestMapping(value = {"/ms_dictionary/remove_modelAttribute"}, method = {RequestMethod.POST})
499 public void removeMicroServiceAttributeDictionary(HttpServletRequest request, HttpServletResponse response)
501 DictionaryUtils utils = getDictionaryUtilsInstance();
502 utils.removeData(request, response, microServiceAttributeDatas, MicroServiceAttribute.class);
506 value = {"/get_MicroServiceModelsDataByName"},
507 method = {RequestMethod.GET},
508 produces = MediaType.APPLICATION_JSON_VALUE)
509 public void getMicroServiceModelsDictionaryByNameEntityData(HttpServletResponse response) {
510 DictionaryUtils utils = getDictionaryUtilsInstance();
511 utils.getDataByEntity(response, microServiceModelsDictionaryDatas, modelName, MicroServiceModels.class);
515 value = {"/get_MicroServiceModelsDataByVersion"},
516 method = {RequestMethod.GET},
517 produces = MediaType.APPLICATION_JSON_VALUE)
518 public void getMicroServiceModelsDictionaryByVersionEntityData(HttpServletRequest request,
519 HttpServletResponse response) {
521 Map<String, Object> model = new HashMap<>();
522 ObjectMapper mapper = new ObjectMapper();
523 JsonNode root = mapper.readTree(request.getReader());
524 String modelName = null;
525 if (root.get(microServiceModelsDictionaryData).has(modelName)) {
526 modelName = root.get(microServiceModelsDictionaryData).get(modelName).asText().replace("\"", "");
528 if (modelName != null) {
529 model.put(microServiceModelsDictionaryDatas, mapper.writeValueAsString(
530 commonClassDao.getDataById(MicroServiceModels.class, modelName, modelName)));
532 model.put(errorMsg, "No model name given");
534 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
535 JSONObject j = new JSONObject(msg);
536 response.getWriter().write(j.toString());
537 } catch (Exception e) {
543 value = {"/get_MicroServiceModelsData"},
544 method = {RequestMethod.GET},
545 produces = MediaType.APPLICATION_JSON_VALUE)
546 public void getMicroServiceModelsDictionaryEntityData(HttpServletResponse response) {
547 DictionaryUtils utils = getDictionaryUtilsInstance();
548 utils.getData(response, microServiceModelsDictionaryDatas, MicroServiceModels.class);
552 value = {"/get_MicroServiceModelsDataServiceVersion"},
553 method = {RequestMethod.GET},
554 produces = MediaType.APPLICATION_JSON_VALUE)
555 public void getMicroServiceModelsDictionaryEntityDataServiceVersion(HttpServletResponse response) {
557 Map<String, Object> model = new HashMap<>();
558 ObjectMapper mapper = new ObjectMapper();
559 List<String> data = new ArrayList<>();
560 List<Object> datas = commonClassDao.getData(MicroServiceModels.class);
561 for (int i = 0; i < datas.size(); i++) {
562 MicroServiceModels msmodel = (MicroServiceModels) datas.get(i);
563 if (!data.contains(msmodel.getModelName())) {
564 data.add(msmodel.getModelName() + "-v" + msmodel.getVersion());
567 model.put(microServiceModelsDictionaryDatas, mapper.writeValueAsString(data));
568 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
569 JSONObject j = new JSONObject(msg);
570 response.addHeader("successMapKey", "success");
571 response.addHeader("operation", "getDictionary");
572 response.getWriter().write(j.toString());
574 } catch (Exception e) {
575 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
576 response.addHeader("error", "dictionaryDBQuery");
582 value = {"/get_MicroServiceModelsDataByClass"},
583 method = {RequestMethod.GET},
584 produces = MediaType.APPLICATION_JSON_VALUE)
585 public void getMicroServiceModelsDictionaryClassEntityData(HttpServletResponse response) {
587 Map<String, Object> model = new HashMap<>();
588 ObjectMapper mapper = new ObjectMapper();
589 model.put("microServiceModelsDictionaryClassDatas", mapper.writeValueAsString(modelList));
590 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
591 JSONObject j = new JSONObject(msg);
592 response.addHeader(successMapKey, successMsg);
593 response.addHeader(operation, getDictionary);
594 response.getWriter().write(j.toString());
596 } catch (Exception e) {
597 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
598 response.addHeader(errorMsg, dictionaryDBQuery);
603 @RequestMapping(value = {"/ms_dictionary/save_model"}, method = {RequestMethod.POST})
604 public ModelAndView saveMicroServiceModelsDictionary(HttpServletRequest request, HttpServletResponse response)
606 DictionaryUtils utils = getDictionaryUtilsInstance();
608 this.newModel = new MicroServiceModels();
609 boolean fromAPI = utils.isRequestFromAPI(request);
610 ObjectMapper mapper = new ObjectMapper();
611 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
612 JsonNode root = mapper.readTree(request.getReader());
613 MicroServiceModels microServiceModels = new MicroServiceModels();
614 String userId = null;
616 String dataOrderInfo = null;
617 if (root.has("dataOrderInfo")) {
618 dataOrderInfo = root.get("dataOrderInfo").toString();
621 if (root.has("modelType")) {
622 JsonNode dataType = root.get("modelType");
623 String modelType = dataType.toString();
624 if (modelType.contains("yml")) {
625 if (root.has(microServiceModelsDictionaryData)) {
626 if (root.get(microServiceModelsDictionaryData).has(description)) {
627 microServiceModels.setDescription(root.get(microServiceModelsDictionaryData)
628 .get(description).asText().replace("\"", ""));
630 if (root.get(microServiceModelsDictionaryData).has(modelName)) {
631 microServiceModels.setModelName(root.get(microServiceModelsDictionaryData).get(modelName)
632 .asText().replace("\"", ""));
633 this.newModel.setModelName(microServiceModels.getModelName());
635 if (root.get(microServiceModelsDictionaryData).has(version)) {
636 microServiceModels.setVersion(
637 root.get(microServiceModelsDictionaryData).get(version).asText().replace("\"", ""));
638 this.newModel.setVersion(microServiceModels.getVersion());
642 classMap = new LinkedHashMap<>();
643 JsonNode data = root.get(classMapData);
644 ObjectMapper mapper1 = new ObjectMapper();
645 String data1 = data.toString().substring(1, data.toString().length() - 1);
646 data1 = data1.replace("\\", "");
647 data1 = data1.replace("\"{", "{");
648 data1 = data1.replace("}\"", "}");
649 JSONObject jsonObject = new JSONObject(data1);
650 Set<String> keys = jsonObject.keySet();
651 for (String key : keys) {
652 String value = jsonObject.get(key).toString();
653 MSAttributeObject msAttributeObject = mapper1.readValue(value, MSAttributeObject.class);
654 classMap.put(key, msAttributeObject);
657 userId = root.get("userid").textValue();
658 MSAttributeObject mainClass = classMap.get(this.newModel.getModelName());
659 this.newModel.setDependency("[]");
660 String value = new Gson().toJson(mainClass.getSubClass());
661 this.newModel.setSub_attributes(value);
662 String attributes = mainClass.getAttribute().toString().replace("{", "").replace("}", "");
663 int equalsIndexForAttributes = attributes.indexOf('=');
664 String atttributesAfterFirstEquals = attributes.substring(equalsIndexForAttributes + 1);
665 this.newModel.setAttributes(atttributesAfterFirstEquals);
666 String refAttributes = mainClass.getRefAttribute().toString().replace("{", "").replace("}", "");
667 int equalsIndex = refAttributes.indexOf("=");
668 String refAttributesAfterFirstEquals = refAttributes.substring(equalsIndex + 1);
669 this.newModel.setRef_attributes(refAttributesAfterFirstEquals);
670 this.newModel.setEnumValues(mainClass.getEnumType().toString().replace("{", "").replace("}", ""));
672 .setAnnotation(mainClass.getMatchingSet().toString().replace("{", "").replace("}", ""));
677 mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceModels.class);
680 if (root.has(microServiceModelsDictionaryData)) {
681 if (root.get(microServiceModelsDictionaryData).has(description)) {
682 microServiceModels.setDescription(root.get(microServiceModelsDictionaryData)
683 .get(description).asText().replace("\"", ""));
685 if (root.get(microServiceModelsDictionaryData).has(modelName)) {
686 microServiceModels.setModelName(root.get(microServiceModelsDictionaryData)
687 .get(modelName).asText().replace("\"", ""));
688 this.newModel.setModelName(microServiceModels.getModelName());
690 if (root.get(microServiceModelsDictionaryData).has(version)) {
691 microServiceModels.setVersion(root.get(microServiceModelsDictionaryData).get(version)
692 .asText().replace("\"", ""));
693 this.newModel.setVersion(microServiceModels.getVersion());
696 if (root.has(classMapData)) {
697 classMap = new LinkedHashMap<>();
698 JsonNode data = root.get(classMapData);
699 ObjectMapper mapper1 = new ObjectMapper();
700 String data1 = data.toString().substring(1, data.toString().length() - 1);
701 data1 = data1.replace("\\", "");
702 JSONObject jsonObject = new JSONObject(data1);
703 Set<String> keys = jsonObject.keySet();
704 for (String key : keys) {
705 String value = jsonObject.get(key).toString();
706 MSAttributeObject msAttributeObject = mapper1.readValue(value, MSAttributeObject.class);
707 classMap.put(key, msAttributeObject);
710 userId = root.get("userid").textValue();
711 addValuesToNewModel(classMap);
715 microServiceModels.setAttributes(this.newModel.getAttributes());
716 microServiceModels.setRef_attributes(this.newModel.getRef_attributes());
717 microServiceModels.setDependency(this.newModel.getDependency());
718 microServiceModels.setModelName(this.newModel.getModelName());
719 microServiceModels.setSub_attributes(this.newModel.getSub_attributes());
720 microServiceModels.setVersion(this.newModel.getVersion());
721 microServiceModels.setEnumValues(this.newModel.getEnumValues());
722 microServiceModels.setAnnotation(this.newModel.getAnnotation());
723 if (dataOrderInfo != null) {
724 microServiceModels.setDataOrderInfo(dataOrderInfo);
726 String checkName = microServiceModels.getModelName() + ":" + microServiceModels.getVersion();
727 List<Object> duplicateData =
728 commonClassDao.checkDuplicateEntry(checkName, "modelName:version", MicroServiceModels.class);
729 boolean duplicateflag = false;
730 if (duplicateData != null && !duplicateData.isEmpty()) {
731 MicroServiceModels data = (MicroServiceModels) duplicateData.get(0);
732 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
733 microServiceModels.setId(data.getId());
734 } else if ((request.getParameter(operation) != null
735 && !"update".equals(request.getParameter(operation)))
736 || (request.getParameter(operation) == null && (data.getId() != microServiceModels.getId()))) {
737 duplicateflag = true;
740 UserInfo userInfo = utils.getUserInfo(userId);
742 String responseString = null;
743 if (!duplicateflag) {
744 microServiceModels.setUserCreatedBy(userInfo);
745 if (microServiceModels.getId() == 0) {
746 commonClassDao.save(microServiceModels);
748 commonClassDao.update(microServiceModels);
750 responseString = mapper.writeValueAsString(commonClassDao.getData(PrefixList.class));
752 responseString = duplicateResponseString;
755 return utils.getResultForApi(responseString);
757 utils.setResponseData(response, microServiceModelsDictionaryDatas, responseString);
759 } catch (Exception e) {
760 utils.setErrorResponseData(response, e);
765 @RequestMapping(value = {"/ms_dictionary/remove_msModel"}, method = {RequestMethod.POST})
766 public void removeMicroServiceModelsDictionary(HttpServletRequest request, HttpServletResponse response)
768 DictionaryUtils utils = getDictionaryUtilsInstance();
769 utils.removeData(request, response, microServiceModelsDictionaryDatas, MicroServiceModels.class);
772 private void addValuesToNewModel(HashMap<String, MSAttributeObject> classMap) {
773 // Loop through the classmap and pull out the required info for the new file.
774 String subAttribute = null;
776 MSAttributeObject mainClass = classMap.get(this.newModel.getModelName());
778 if (mainClass != null) {
779 String dependTemp = StringUtils.replaceEach(mainClass.getDependency(), new String[] {"[", "]", " "},
780 new String[] {"", "", ""});
781 ArrayList<String> dependency = new ArrayList<>(Arrays.asList(dependTemp.split(",")));
782 dependency = getFullDependencyList(dependency);
783 for (String element : dependency) {
784 MSAttributeObject temp = classMap.get(element);
786 mainClass.addAllRefAttribute(temp.getRefAttribute());
787 mainClass.addAllAttribute(temp.getAttribute());
790 subAttribute = utils.createSubAttributes(dependency, classMap, this.newModel.getModelName());
793 this.newModel.setDependency("");
796 if (mainClass != null && mainClass.getDependency() == null) {
797 mainClass.setDependency("");
799 if (mainClass != null) {
800 this.newModel.setDependency(mainClass.getDependency());
801 this.newModel.setSub_attributes(subAttribute);
802 this.newModel.setAttributes(mainClass.getAttribute().toString().replace("{", "").replace("}", ""));
803 this.newModel.setRef_attributes(mainClass.getRefAttribute().toString().replace("{", "").replace("}", ""));
804 this.newModel.setEnumValues(mainClass.getEnumType().toString().replace("{", "").replace("}", ""));
805 this.newModel.setAnnotation(mainClass.getMatchingSet().toString().replace("{", "").replace("}", ""));
809 private ArrayList<String> getFullDependencyList(ArrayList<String> dependency) {
810 ArrayList<String> returnList = new ArrayList<>();
811 ArrayList<String> workingList = new ArrayList<>();
812 returnList.addAll(dependency);
813 for (String element : dependency) {
814 if (classMap.containsKey(element)) {
815 MSAttributeObject value = classMap.get(element);
817 StringUtils.replaceEach(value.getDependency(), new String[] {"[", "]"}, new String[] {"", ""});
818 workingList = new ArrayList<>(Arrays.asList(rawValue.split(",")));
819 for (String depend : workingList) {
820 if (!returnList.contains(depend) && !depend.isEmpty()) {
821 returnList.add(depend.trim());
822 // getFullDepedency(workingList)
832 value = {"/get_MicroServiceHeaderDefaultsDataByName"},
833 method = {RequestMethod.GET},
834 produces = MediaType.APPLICATION_JSON_VALUE)
835 public void getMicroServiceHeaderDefaultsEntityDataByName(HttpServletResponse response) {
836 DictionaryUtils utils = getDictionaryUtilsInstance();
837 utils.getDataByEntity(response, microServiceHeaderDefaultDatas, "modelName", MicroserviceHeaderdeFaults.class);
841 value = {"/get_MicroServiceHeaderDefaultsData"},
842 method = {RequestMethod.GET},
843 produces = MediaType.APPLICATION_JSON_VALUE)
844 public void getMicroServiceHeaderDefaultsEntityData(HttpServletResponse response) {
845 DictionaryUtils utils = getDictionaryUtilsInstance();
846 utils.getData(response, microServiceHeaderDefaultDatas, MicroserviceHeaderdeFaults.class);
849 @RequestMapping(value = {"/ms_dictionary/save_headerDefaults"}, method = {RequestMethod.POST})
850 public ModelAndView saveMicroServiceHeaderDefaultValues(HttpServletRequest request, HttpServletResponse response)
852 DictionaryUtils utils = getDictionaryUtilsInstance();
854 boolean fromAPI = utils.isRequestFromAPI(request);
855 ObjectMapper mapper = new ObjectMapper();
856 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
857 JsonNode root = mapper.readTree(request.getReader());
859 MicroserviceHeaderdeFaults msHeaderdeFaults;
862 mapper.readValue(root.get(dictionaryFields).toString(), MicroserviceHeaderdeFaults.class);
864 msHeaderdeFaults = mapper.readValue(root.get("modelAttributeDictionaryData").toString(),
865 MicroserviceHeaderdeFaults.class);
868 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(msHeaderdeFaults.getModelName(),
869 "modelName", MicroserviceHeaderdeFaults.class);
870 boolean duplicateflag = false;
871 if (duplicateData != null && !duplicateData.isEmpty()) {
872 MicroserviceHeaderdeFaults data = (MicroserviceHeaderdeFaults) duplicateData.get(0);
873 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
874 msHeaderdeFaults.setId(data.getId());
875 } else if ((request.getParameter(operation) != null
876 && !"update".equals(request.getParameter(operation)))
877 || (request.getParameter(operation) == null && (data.getId() != msHeaderdeFaults.getId()))) {
878 duplicateflag = true;
882 String responseString = null;
883 if (!duplicateflag) {
884 if (msHeaderdeFaults.getId() == 0) {
885 commonClassDao.save(msHeaderdeFaults);
887 commonClassDao.update(msHeaderdeFaults);
889 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroserviceHeaderdeFaults.class));
891 responseString = duplicateResponseString;
894 return utils.getResultForApi(responseString);
896 utils.setResponseData(response, microServiceHeaderDefaultDatas, responseString);
898 } catch (Exception e) {
899 utils.setErrorResponseData(response, e);
904 @RequestMapping(value = {"/ms_dictionary/remove_headerDefaults"}, method = {RequestMethod.POST})
905 public void removeMicroServiceHeaderDefaults(HttpServletRequest request, HttpServletResponse response)
907 DictionaryUtils utils = getDictionaryUtilsInstance();
908 utils.removeData(request, response, microServiceHeaderDefaultDatas, MicroserviceHeaderdeFaults.class);