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;
27 import java.io.IOException;
28 import java.util.ArrayList;
29 import java.util.Arrays;
30 import java.util.HashMap;
31 import java.util.LinkedHashMap;
32 import java.util.List;
35 import javax.servlet.http.HttpServletRequest;
36 import javax.servlet.http.HttpServletResponse;
37 import org.apache.commons.lang.StringUtils;
38 import org.json.JSONObject;
39 import org.onap.policy.common.logging.flexlogger.FlexLogger;
40 import org.onap.policy.common.logging.flexlogger.Logger;
41 import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
42 import org.onap.policy.pap.xacml.rest.util.DictionaryUtils;
43 import org.onap.policy.pap.xacml.rest.util.JsonMessage;
44 import org.onap.policy.rest.dao.CommonClassDao;
45 import org.onap.policy.rest.jpa.DCAEuuid;
46 import org.onap.policy.rest.jpa.DictionaryData;
47 import org.onap.policy.rest.jpa.MicroServiceAttribute;
48 import org.onap.policy.rest.jpa.MicroServiceConfigName;
49 import org.onap.policy.rest.jpa.MicroServiceLocation;
50 import org.onap.policy.rest.jpa.MicroServiceModels;
51 import org.onap.policy.rest.jpa.MicroserviceHeaderdeFaults;
52 import org.onap.policy.rest.jpa.PrefixList;
53 import org.onap.policy.rest.jpa.UserInfo;
54 import org.onap.policy.rest.util.MSAttributeObject;
55 import org.onap.policy.rest.util.MSModelUtils;
56 import org.springframework.beans.factory.annotation.Autowired;
57 import org.springframework.http.MediaType;
58 import org.springframework.stereotype.Controller;
59 import org.springframework.web.bind.annotation.RequestMapping;
60 import org.springframework.web.bind.annotation.RequestMethod;
61 import org.springframework.web.servlet.ModelAndView;
64 public class MicroServiceDictionaryController {
65 private static final Logger LOGGER = FlexLogger.getLogger(MicroServiceDictionaryController.class);
67 private static CommonClassDao commonClassDao;
69 private static String successMapKey = "successMapKey";
70 private static String successMsg = "success";
71 private static String operation = "operation";
72 private static String getDictionary = "getDictionary";
73 private static String errorMsg = "error";
74 private static String dictionaryDBQuery = "dictionaryDBQuery";
75 private LinkedHashMap<String, MSAttributeObject> classMap;
76 private List<String> modelList = new ArrayList<>();
77 private static String dictionaryFields = "dictionaryFields";
78 private static String duplicateResponseString = "Duplicate";
79 private static String microServiceModelsDictionaryDatas = "microServiceModelsDictionaryDatas";
80 private static String modelName = "modelName";
81 private static String microServiceModelsDictionaryData = "microServiceModelsDictionaryData";
82 private static String description = "description";
83 private static String version = "version";
84 private static String classMapData = "classMap";
85 private static String dcaeUUIDDatas = "dcaeUUIDDictionaryDatas";
86 private static String microServiceConfigNameDatas = "microServiceConfigNameDictionaryDatas";
87 private static String microServiceLocationDatas = "microServiceLocationDictionaryDatas";
88 private static String microServiceAttributeDatas = "microServiceAttributeDictionaryDatas";
89 private static String microServiceHeaderDefaultDatas = "microServiceHeaderDefaultDatas";
90 private static final String MICROSERVICEDICTNAMEDATAS = "microServiceDictionaryDatas";
92 public MicroServiceDictionaryController() {
96 private DictionaryUtils getDictionaryUtilsInstance() {
97 return DictionaryUtils.getDictionaryUtils();
101 public MicroServiceDictionaryController(CommonClassDao commonClassDao) {
102 MicroServiceDictionaryController.commonClassDao = commonClassDao;
105 public static void setCommonClassDao(CommonClassDao commonClassDao) {
106 MicroServiceDictionaryController.commonClassDao = commonClassDao;
109 MSModelUtils utils = new MSModelUtils(XACMLPapServlet.getMsOnapName(), XACMLPapServlet.getMsPolicyName());
111 private MicroServiceModels newModel;
113 @RequestMapping(value = {"/get_DCAEUUIDDataByName"}, method = {RequestMethod.GET},
114 produces = MediaType.APPLICATION_JSON_VALUE)
115 public void getDCAEUUIDDictionaryByNameEntityData(HttpServletResponse response) {
116 DictionaryUtils utils = getDictionaryUtilsInstance();
117 utils.getDataByEntity(response, dcaeUUIDDatas, "name", DCAEuuid.class);
120 @RequestMapping(value = {"/get_DCAEUUIDData"}, method = {RequestMethod.GET},
121 produces = MediaType.APPLICATION_JSON_VALUE)
122 public void getDCAEUUIDDictionaryEntityData(HttpServletResponse response) {
123 DictionaryUtils utils = getDictionaryUtilsInstance();
124 utils.getData(response, dcaeUUIDDatas, DCAEuuid.class);
127 @RequestMapping(value = {"/ms_dictionary/save_dcaeUUID"}, method = {RequestMethod.POST})
128 public ModelAndView saveDCAEUUIDDictionary(HttpServletRequest request, HttpServletResponse response)
130 DictionaryUtils utils = getDictionaryUtilsInstance();
132 boolean fromAPI = utils.isRequestFromAPI(request);
133 ObjectMapper mapper = new ObjectMapper();
134 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
135 JsonNode root = mapper.readTree(request.getReader());
138 dCAEuuid = mapper.readValue(root.get(dictionaryFields).toString(), DCAEuuid.class);
140 dCAEuuid = mapper.readValue(root.get("dcaeUUIDDictionaryData").toString(), DCAEuuid.class);
143 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(dCAEuuid.getName(), "name", DCAEuuid.class);
144 boolean duplicateflag = false;
145 if (duplicateData != null && !duplicateData.isEmpty()) {
146 DCAEuuid data = (DCAEuuid) duplicateData.get(0);
147 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
148 dCAEuuid.setId(data.getId());
149 } else if ((request.getParameter(operation) != null
150 && !"update".equals(request.getParameter(operation)))
151 || (request.getParameter(operation) == null && (data.getId() != dCAEuuid.getId()))) {
152 duplicateflag = true;
155 String responseString = null;
156 if (!duplicateflag) {
157 if (dCAEuuid.getId() == 0) {
158 commonClassDao.save(dCAEuuid);
160 commonClassDao.update(dCAEuuid);
162 responseString = mapper.writeValueAsString(commonClassDao.getData(DCAEuuid.class));
164 responseString = duplicateResponseString;
167 return utils.getResultForApi(responseString);
169 utils.setResponseData(response, dcaeUUIDDatas, responseString);
171 } catch (Exception e) {
172 utils.setErrorResponseData(response, e);
177 @RequestMapping(value = {"/ms_dictionary/remove_dcaeuuid"}, method = {RequestMethod.POST})
178 public void removeDCAEUUIDDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException {
179 DictionaryUtils utils = getDictionaryUtilsInstance();
180 utils.removeData(request, response, dcaeUUIDDatas, DCAEuuid.class);
183 @RequestMapping(value = {"/get_MicroServiceConfigNameDataByName"}, method = {RequestMethod.GET},
184 produces = MediaType.APPLICATION_JSON_VALUE)
185 public void getMicroServiceConfigNameByNameDictionaryEntityData(HttpServletResponse response) {
186 DictionaryUtils utils = getDictionaryUtilsInstance();
187 utils.getDataByEntity(response, microServiceConfigNameDatas, "name", MicroServiceConfigName.class);
190 @RequestMapping(value = {"/get_MicroServiceConfigNameData"}, method = {RequestMethod.GET},
191 produces = MediaType.APPLICATION_JSON_VALUE)
192 public void getMicroServiceConfigNameDictionaryEntityData(HttpServletResponse response) {
193 DictionaryUtils utils = getDictionaryUtilsInstance();
194 utils.getData(response, microServiceConfigNameDatas, MicroServiceConfigName.class);
197 @RequestMapping(value = {"/get_MicroServiceDictData"}, method = {RequestMethod.GET},
198 produces = MediaType.APPLICATION_JSON_VALUE)
199 public void getMicroServiceDictNameDictionaryEntityData(HttpServletResponse response) {
200 DictionaryUtils utils = getDictionaryUtilsInstance();
201 utils.getData(response, MICROSERVICEDICTNAMEDATAS, DictionaryData.class);
205 * Save dictionary data.
207 * @param request the request
208 * @param response the response
209 * @return the model and view
210 * @throws IOException Signals that an I/O exception has occurred.
212 // save_DictionaryData
213 @RequestMapping(value = {"/ms_dictionary/save_DictionaryData"}, method = {RequestMethod.POST})
214 public ModelAndView saveDictionaryData(HttpServletRequest request, HttpServletResponse response)
216 DictionaryUtils dictUtil = getDictionaryUtilsInstance();
218 boolean fromApi = dictUtil.isRequestFromAPI(request);
219 ObjectMapper mapper = new ObjectMapper();
220 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
221 JsonNode root = mapper.readTree(request.getReader());
222 DictionaryData dictionaryData;
224 dictionaryData = mapper.readValue(root.get(dictionaryFields).toString(), DictionaryData.class);
226 dictionaryData = mapper.readValue(root.get(MICROSERVICEDICTNAMEDATAS).toString(), DictionaryData.class);
228 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(dictionaryData.getDictionaryName(),
229 "dictionaryName", DictionaryData.class);
230 boolean duplicateflag = false;
231 if (duplicateData != null && !duplicateData.isEmpty()) {
232 DictionaryData data = (DictionaryData) duplicateData.get(0);
233 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
234 dictionaryData.setId(data.getId());
235 } else if ((request.getParameter(operation) != null
236 && !"update".equals(request.getParameter(operation)))
237 || (request.getParameter(operation) == null && (data.getId() != dictionaryData.getId()))) {
238 duplicateflag = true;
241 String responseString = null;
242 if (!duplicateflag) {
243 if (dictionaryData.getId() == 0) {
244 commonClassDao.save(dictionaryData);
246 commonClassDao.update(dictionaryData);
248 responseString = mapper.writeValueAsString(commonClassDao.getData(DictionaryData.class));
250 responseString = duplicateResponseString;
253 return dictUtil.getResultForApi(responseString);
255 dictUtil.setResponseData(response, MICROSERVICEDICTNAMEDATAS, responseString);
257 } catch (Exception e) {
258 dictUtil.setErrorResponseData(response, e);
263 @RequestMapping(value = {"/ms_dictionary/remove_msDictionaryData"}, method = {RequestMethod.POST})
264 public void removeMicroServiceDictionaryData(HttpServletRequest request, HttpServletResponse response)
266 DictionaryUtils utils = getDictionaryUtilsInstance();
267 utils.removeData(request, response, MICROSERVICEDICTNAMEDATAS, DictionaryData.class);
271 @RequestMapping(value = {"/ms_dictionary/save_configName"}, method = {RequestMethod.POST})
272 public ModelAndView saveMicroServiceConfigNameDictionary(HttpServletRequest request, HttpServletResponse response)
274 DictionaryUtils utils = getDictionaryUtilsInstance();
276 boolean fromAPI = utils.isRequestFromAPI(request);
277 ObjectMapper mapper = new ObjectMapper();
278 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
279 JsonNode root = mapper.readTree(request.getReader());
280 MicroServiceConfigName microServiceConfigName;
282 microServiceConfigName =
283 mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceConfigName.class);
285 microServiceConfigName = mapper.readValue(root.get("microServiceConfigNameDictionaryData").toString(),
286 MicroServiceConfigName.class);
288 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(microServiceConfigName.getName(), "name",
289 MicroServiceConfigName.class);
290 boolean duplicateflag = false;
291 if (duplicateData != null && !duplicateData.isEmpty()) {
292 MicroServiceConfigName data = (MicroServiceConfigName) duplicateData.get(0);
293 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
294 microServiceConfigName.setId(data.getId());
295 } else if ((request.getParameter(operation) != null
296 && !"update".equals(request.getParameter(operation)))
297 || (request.getParameter(operation) == null
298 && (data.getId() != microServiceConfigName.getId()))) {
299 duplicateflag = true;
302 String responseString = null;
303 if (!duplicateflag) {
304 if (microServiceConfigName.getId() == 0) {
305 commonClassDao.save(microServiceConfigName);
307 commonClassDao.update(microServiceConfigName);
309 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceConfigName.class));
311 responseString = duplicateResponseString;
314 return utils.getResultForApi(responseString);
316 utils.setResponseData(response, microServiceConfigNameDatas, responseString);
318 } catch (Exception e) {
319 utils.setErrorResponseData(response, e);
324 @RequestMapping(value = {"/ms_dictionary/remove_msConfigName"}, method = {RequestMethod.POST})
325 public void removeMicroServiceConfigNameDictionary(HttpServletRequest request, HttpServletResponse response)
327 DictionaryUtils utils = getDictionaryUtilsInstance();
328 utils.removeData(request, response, microServiceConfigNameDatas, MicroServiceConfigName.class);
331 @RequestMapping(value = {"/get_MicroServiceLocationDataByName"}, method = {RequestMethod.GET},
332 produces = MediaType.APPLICATION_JSON_VALUE)
333 public void getMicroServiceLocationByNameDictionaryEntityData(HttpServletResponse response) {
334 DictionaryUtils utils = getDictionaryUtilsInstance();
335 utils.getDataByEntity(response, microServiceLocationDatas, "name", MicroServiceLocation.class);
338 @RequestMapping(value = {"/get_MicroServiceLocationData"}, method = {RequestMethod.GET},
339 produces = MediaType.APPLICATION_JSON_VALUE)
340 public void getMicroServiceLocationDictionaryEntityData(HttpServletResponse response) {
341 DictionaryUtils utils = getDictionaryUtilsInstance();
342 utils.getData(response, microServiceLocationDatas, MicroServiceLocation.class);
345 @RequestMapping(value = {"/ms_dictionary/save_location"}, method = {RequestMethod.POST})
346 public ModelAndView saveMicroServiceLocationDictionary(HttpServletRequest request, HttpServletResponse response)
348 DictionaryUtils utils = getDictionaryUtilsInstance();
350 boolean fromAPI = utils.isRequestFromAPI(request);
351 ObjectMapper mapper = new ObjectMapper();
352 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
353 JsonNode root = mapper.readTree(request.getReader());
354 MicroServiceLocation microServiceLocation;
356 microServiceLocation =
357 mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceLocation.class);
359 microServiceLocation = mapper.readValue(root.get("microServiceLocationDictionaryData").toString(),
360 MicroServiceLocation.class);
363 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(microServiceLocation.getName(), "name",
364 MicroServiceLocation.class);
365 boolean duplicateflag = false;
366 if (duplicateData != null && !duplicateData.isEmpty()) {
367 MicroServiceLocation data = (MicroServiceLocation) duplicateData.get(0);
368 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
369 microServiceLocation.setId(data.getId());
370 } else if ((request.getParameter(operation) != null
371 && !"update".equals(request.getParameter(operation)))
372 || (request.getParameter(operation) == null
373 && (data.getId() != microServiceLocation.getId()))) {
374 duplicateflag = true;
377 String responseString = null;
378 if (!duplicateflag) {
379 if (microServiceLocation.getId() == 0) {
380 commonClassDao.save(microServiceLocation);
382 commonClassDao.update(microServiceLocation);
384 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceLocation.class));
386 responseString = duplicateResponseString;
389 return utils.getResultForApi(responseString);
391 utils.setResponseData(response, microServiceLocationDatas, responseString);
393 } catch (Exception e) {
394 utils.setErrorResponseData(response, e);
399 @RequestMapping(value = {"/ms_dictionary/remove_msLocation"}, method = {RequestMethod.POST})
400 public void removeMicroServiceLocationDictionary(HttpServletRequest request, HttpServletResponse response)
402 DictionaryUtils utils = getDictionaryUtilsInstance();
403 utils.removeData(request, response, microServiceLocationDatas, MicroServiceLocation.class);
406 @RequestMapping(value = {"/get_MicroServiceAttributeDataByName"}, method = {RequestMethod.GET},
407 produces = MediaType.APPLICATION_JSON_VALUE)
408 public void getMicroServiceAttributeByNameDictionaryEntityData(HttpServletResponse response) {
409 DictionaryUtils utils = getDictionaryUtilsInstance();
410 utils.getDataByEntity(response, microServiceAttributeDatas, "name", MicroServiceAttribute.class);
413 @RequestMapping(value = {"/get_MicroServiceAttributeData"}, method = {RequestMethod.GET},
414 produces = MediaType.APPLICATION_JSON_VALUE)
415 public void getMicroServiceAttributeDictionaryEntityData(HttpServletResponse response) {
416 DictionaryUtils utils = getDictionaryUtilsInstance();
417 utils.getData(response, microServiceAttributeDatas, MicroServiceAttribute.class);
420 @RequestMapping(value = {"/ms_dictionary/save_modelAttribute"}, method = {RequestMethod.POST})
421 public ModelAndView saveMicroServiceAttributeDictionary(HttpServletRequest request, HttpServletResponse response)
423 DictionaryUtils utils = getDictionaryUtilsInstance();
425 boolean fromAPI = utils.isRequestFromAPI(request);
426 ObjectMapper mapper = new ObjectMapper();
427 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
428 JsonNode root = mapper.readTree(request.getReader());
430 MicroServiceAttribute microServiceAttribute;
433 microServiceAttribute =
434 mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceAttribute.class);
436 microServiceAttribute = mapper.readValue(root.get("modelAttributeDictionaryData").toString(),
437 MicroServiceAttribute.class);
439 checkValue = microServiceAttribute.getName() + ":" + microServiceAttribute.getValue() + ":"
440 + microServiceAttribute.getModelName();
441 List<Object> duplicateData =
442 commonClassDao.checkDuplicateEntry(checkValue, "name:value:modelName", MicroServiceAttribute.class);
443 boolean duplicateflag = false;
444 if (duplicateData != null && !duplicateData.isEmpty()) {
445 MicroServiceAttribute data = (MicroServiceAttribute) duplicateData.get(0);
446 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
447 microServiceAttribute.setId(data.getId());
448 } else if ((request.getParameter(operation) != null
449 && !"update".equals(request.getParameter(operation)))
450 || (request.getParameter(operation) == null
451 && (data.getId() != microServiceAttribute.getId()))) {
452 duplicateflag = true;
455 String responseString = null;
456 if (!duplicateflag) {
457 if (microServiceAttribute.getId() == 0) {
458 commonClassDao.save(microServiceAttribute);
460 commonClassDao.update(microServiceAttribute);
462 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceAttribute.class));
464 responseString = duplicateResponseString;
467 return utils.getResultForApi(responseString);
469 utils.setResponseData(response, microServiceAttributeDatas, responseString);
471 } catch (Exception e) {
472 utils.setErrorResponseData(response, e);
477 @RequestMapping(value = {"/ms_dictionary/remove_modelAttribute"}, method = {RequestMethod.POST})
478 public void removeMicroServiceAttributeDictionary(HttpServletRequest request, HttpServletResponse response)
480 DictionaryUtils utils = getDictionaryUtilsInstance();
481 utils.removeData(request, response, microServiceAttributeDatas, MicroServiceAttribute.class);
485 @RequestMapping(value = {"/get_MicroServiceModelsDataByName"}, method = {RequestMethod.GET},
486 produces = MediaType.APPLICATION_JSON_VALUE)
487 public void getMicroServiceModelsDictionaryByNameEntityData(HttpServletResponse response) {
488 DictionaryUtils utils = getDictionaryUtilsInstance();
489 utils.getDataByEntity(response, microServiceModelsDictionaryDatas, modelName, MicroServiceModels.class);
492 @RequestMapping(value = {"/get_MicroServiceModelsDataByVersion"}, method = {RequestMethod.GET},
493 produces = MediaType.APPLICATION_JSON_VALUE)
494 public void getMicroServiceModelsDictionaryByVersionEntityData(HttpServletRequest request,
495 HttpServletResponse response) {
497 Map<String, Object> model = new HashMap<>();
498 ObjectMapper mapper = new ObjectMapper();
499 JsonNode root = mapper.readTree(request.getReader());
500 String modelName = null;
501 if (root.get(microServiceModelsDictionaryData).has(modelName)) {
502 modelName = root.get(microServiceModelsDictionaryData).get(modelName).asText().replace("\"", "");
504 if (modelName != null) {
505 model.put(microServiceModelsDictionaryDatas, mapper.writeValueAsString(
506 commonClassDao.getDataById(MicroServiceModels.class, modelName, modelName)));
508 model.put(errorMsg, "No model name given");
510 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
511 JSONObject j = new JSONObject(msg);
512 response.getWriter().write(j.toString());
513 } catch (Exception e) {
518 @RequestMapping(value = {"/get_MicroServiceModelsData"}, method = {RequestMethod.GET},
519 produces = MediaType.APPLICATION_JSON_VALUE)
520 public void getMicroServiceModelsDictionaryEntityData(HttpServletResponse response) {
521 DictionaryUtils utils = getDictionaryUtilsInstance();
522 utils.getData(response, microServiceModelsDictionaryDatas, MicroServiceModels.class);
525 @RequestMapping(value = {"/get_MicroServiceModelsDataServiceVersion"}, method = {RequestMethod.GET},
526 produces = MediaType.APPLICATION_JSON_VALUE)
527 public void getMicroServiceModelsDictionaryEntityDataServiceVersion(HttpServletResponse response) {
529 Map<String, Object> model = new HashMap<>();
530 ObjectMapper mapper = new ObjectMapper();
531 List<String> data = new ArrayList<>();
532 List<Object> datas = commonClassDao.getData(MicroServiceModels.class);
533 for (int i = 0; i < datas.size(); i++) {
534 MicroServiceModels msmodel = (MicroServiceModels) datas.get(i);
535 if (!data.contains(msmodel.getModelName())) {
536 data.add(msmodel.getModelName() + "-v" + msmodel.getVersion());
539 model.put(microServiceModelsDictionaryDatas, mapper.writeValueAsString(data));
540 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
541 JSONObject j = new JSONObject(msg);
542 response.addHeader("successMapKey", "success");
543 response.addHeader("operation", "getDictionary");
544 response.getWriter().write(j.toString());
546 } catch (Exception e) {
547 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
548 response.addHeader("error", "dictionaryDBQuery");
553 @RequestMapping(value = {"/get_MicroServiceModelsDataByClass"}, method = {RequestMethod.GET},
554 produces = MediaType.APPLICATION_JSON_VALUE)
555 public void getMicroServiceModelsDictionaryClassEntityData(HttpServletResponse response) {
557 Map<String, Object> model = new HashMap<>();
558 ObjectMapper mapper = new ObjectMapper();
559 model.put("microServiceModelsDictionaryClassDatas", mapper.writeValueAsString(modelList));
560 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
561 JSONObject j = new JSONObject(msg);
562 response.addHeader(successMapKey, successMsg);
563 response.addHeader(operation, getDictionary);
564 response.getWriter().write(j.toString());
566 } catch (Exception e) {
567 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
568 response.addHeader(errorMsg, dictionaryDBQuery);
573 @RequestMapping(value = {"/ms_dictionary/save_model"}, method = {RequestMethod.POST})
574 public ModelAndView saveMicroServiceModelsDictionary(HttpServletRequest request, HttpServletResponse response)
576 DictionaryUtils utils = getDictionaryUtilsInstance();
578 this.newModel = new MicroServiceModels();
579 boolean fromAPI = utils.isRequestFromAPI(request);
580 ObjectMapper mapper = new ObjectMapper();
581 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
582 JsonNode root = mapper.readTree(request.getReader());
583 MicroServiceModels microServiceModels = new MicroServiceModels();
584 String userId = null;
586 String dataOrderInfo = null;
587 if (root.has("dataOrderInfo")) {
588 dataOrderInfo = root.get("dataOrderInfo").toString();
591 if (root.has("modelType")) {
592 JsonNode dataType = root.get("modelType");
593 String modelType = dataType.toString();
594 if (modelType.contains("yml")) {
595 if (root.has(microServiceModelsDictionaryData)) {
596 if (root.get(microServiceModelsDictionaryData).has(description)) {
597 microServiceModels.setDescription(root.get(microServiceModelsDictionaryData)
598 .get(description).asText().replace("\"", ""));
600 if (root.get(microServiceModelsDictionaryData).has(modelName)) {
601 microServiceModels.setModelName(root.get(microServiceModelsDictionaryData).get(modelName)
602 .asText().replace("\"", ""));
603 this.newModel.setModelName(microServiceModels.getModelName());
605 if (root.get(microServiceModelsDictionaryData).has(version)) {
606 microServiceModels.setVersion(
607 root.get(microServiceModelsDictionaryData).get(version).asText().replace("\"", ""));
608 this.newModel.setVersion(microServiceModels.getVersion());
612 classMap = new LinkedHashMap<>();
613 JsonNode data = root.get(classMapData);
614 ObjectMapper mapper1 = new ObjectMapper();
615 String data1 = data.toString().substring(1, data.toString().length() - 1);
616 data1 = data1.replace("\\", "");
617 data1 = data1.replace("\"{", "{");
618 data1 = data1.replace("}\"", "}");
619 JSONObject jsonObject = new JSONObject(data1);
620 Set<String> keys = jsonObject.keySet();
621 for (String key : keys) {
622 String value = jsonObject.get(key).toString();
623 MSAttributeObject msAttributeObject = mapper1.readValue(value, MSAttributeObject.class);
624 classMap.put(key, msAttributeObject);
627 userId = root.get("userid").textValue();
628 MSAttributeObject mainClass = classMap.get(this.newModel.getModelName());
629 this.newModel.setDependency("[]");
630 String value = new Gson().toJson(mainClass.getSubClass());
631 this.newModel.setSub_attributes(value);
632 String attributes = mainClass.getAttribute().toString().replace("{", "").replace("}", "");
633 int equalsIndexForAttributes = attributes.indexOf('=');
634 String atttributesAfterFirstEquals = attributes.substring(equalsIndexForAttributes + 1);
635 this.newModel.setAttributes(atttributesAfterFirstEquals);
636 String refAttributes = mainClass.getRefAttribute().toString().replace("{", "").replace("}", "");
637 int equalsIndex = refAttributes.indexOf("=");
638 String refAttributesAfterFirstEquals = refAttributes.substring(equalsIndex + 1);
639 this.newModel.setRef_attributes(refAttributesAfterFirstEquals);
640 this.newModel.setEnumValues(mainClass.getEnumType().toString().replace("{", "").replace("}", ""));
642 .setAnnotation(mainClass.getMatchingSet().toString().replace("{", "").replace("}", ""));
647 mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceModels.class);
650 if (root.has(microServiceModelsDictionaryData)) {
651 if (root.get(microServiceModelsDictionaryData).has(description)) {
652 microServiceModels.setDescription(root.get(microServiceModelsDictionaryData)
653 .get(description).asText().replace("\"", ""));
655 if (root.get(microServiceModelsDictionaryData).has(modelName)) {
656 microServiceModels.setModelName(root.get(microServiceModelsDictionaryData)
657 .get(modelName).asText().replace("\"", ""));
658 this.newModel.setModelName(microServiceModels.getModelName());
660 if (root.get(microServiceModelsDictionaryData).has(version)) {
661 microServiceModels.setVersion(root.get(microServiceModelsDictionaryData).get(version)
662 .asText().replace("\"", ""));
663 this.newModel.setVersion(microServiceModels.getVersion());
666 if (root.has(classMapData)) {
667 classMap = new LinkedHashMap<>();
668 JsonNode data = root.get(classMapData);
669 ObjectMapper mapper1 = new ObjectMapper();
670 String data1 = data.toString().substring(1, data.toString().length() - 1);
671 data1 = data1.replace("\\", "");
672 JSONObject jsonObject = new JSONObject(data1);
673 Set<String> keys = jsonObject.keySet();
674 for (String key : keys) {
675 String value = jsonObject.get(key).toString();
676 MSAttributeObject msAttributeObject = mapper1.readValue(value, MSAttributeObject.class);
677 classMap.put(key, msAttributeObject);
680 userId = root.get("userid").textValue();
681 addValuesToNewModel(classMap);
685 microServiceModels.setAttributes(this.newModel.getAttributes());
686 microServiceModels.setRef_attributes(this.newModel.getRef_attributes());
687 microServiceModels.setDependency(this.newModel.getDependency());
688 microServiceModels.setModelName(this.newModel.getModelName());
689 microServiceModels.setSub_attributes(this.newModel.getSub_attributes());
690 microServiceModels.setVersion(this.newModel.getVersion());
691 microServiceModels.setEnumValues(this.newModel.getEnumValues());
692 microServiceModels.setAnnotation(this.newModel.getAnnotation());
693 if (dataOrderInfo != null) {
694 microServiceModels.setDataOrderInfo(dataOrderInfo);
696 String checkName = microServiceModels.getModelName() + ":" + microServiceModels.getVersion();
697 List<Object> duplicateData =
698 commonClassDao.checkDuplicateEntry(checkName, "modelName:version", MicroServiceModels.class);
699 boolean duplicateflag = false;
700 if (duplicateData != null && !duplicateData.isEmpty()) {
701 MicroServiceModels data = (MicroServiceModels) duplicateData.get(0);
702 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
703 microServiceModels.setId(data.getId());
704 } else if ((request.getParameter(operation) != null
705 && !"update".equals(request.getParameter(operation)))
706 || (request.getParameter(operation) == null && (data.getId() != microServiceModels.getId()))) {
707 duplicateflag = true;
710 UserInfo userInfo = utils.getUserInfo(userId);
712 String responseString = null;
713 if (!duplicateflag) {
714 microServiceModels.setUserCreatedBy(userInfo);
715 if (microServiceModels.getId() == 0) {
716 commonClassDao.save(microServiceModels);
718 commonClassDao.update(microServiceModels);
720 responseString = mapper.writeValueAsString(commonClassDao.getData(PrefixList.class));
722 responseString = duplicateResponseString;
725 return utils.getResultForApi(responseString);
727 utils.setResponseData(response, microServiceModelsDictionaryDatas, responseString);
729 } catch (Exception e) {
730 utils.setErrorResponseData(response, e);
735 @RequestMapping(value = {"/ms_dictionary/remove_msModel"}, method = {RequestMethod.POST})
736 public void removeMicroServiceModelsDictionary(HttpServletRequest request, HttpServletResponse response)
738 DictionaryUtils utils = getDictionaryUtilsInstance();
739 utils.removeData(request, response, microServiceModelsDictionaryDatas, MicroServiceModels.class);
742 private void addValuesToNewModel(HashMap<String, MSAttributeObject> classMap) {
743 // Loop through the classmap and pull out the required info for the new file.
744 String subAttribute = null;
746 MSAttributeObject mainClass = classMap.get(this.newModel.getModelName());
748 if (mainClass != null) {
749 String dependTemp = StringUtils.replaceEach(mainClass.getDependency(), new String[] {"[", "]", " "},
750 new String[] {"", "", ""});
751 ArrayList<String> dependency = new ArrayList<>(Arrays.asList(dependTemp.split(",")));
752 dependency = getFullDependencyList(dependency);
753 for (String element : dependency) {
754 MSAttributeObject temp = classMap.get(element);
756 mainClass.addAllRefAttribute(temp.getRefAttribute());
757 mainClass.addAllAttribute(temp.getAttribute());
760 subAttribute = utils.createSubAttributes(dependency, classMap, this.newModel.getModelName());
763 this.newModel.setDependency("");
766 if (mainClass != null && mainClass.getDependency() == null) {
767 mainClass.setDependency("");
769 if (mainClass != null) {
770 this.newModel.setDependency(mainClass.getDependency());
771 this.newModel.setSub_attributes(subAttribute);
772 this.newModel.setAttributes(mainClass.getAttribute().toString().replace("{", "").replace("}", ""));
773 this.newModel.setRef_attributes(mainClass.getRefAttribute().toString().replace("{", "").replace("}", ""));
774 this.newModel.setEnumValues(mainClass.getEnumType().toString().replace("{", "").replace("}", ""));
775 this.newModel.setAnnotation(mainClass.getMatchingSet().toString().replace("{", "").replace("}", ""));
779 private ArrayList<String> getFullDependencyList(ArrayList<String> dependency) {
780 ArrayList<String> returnList = new ArrayList<>();
781 ArrayList<String> workingList = new ArrayList<>();
782 returnList.addAll(dependency);
783 for (String element : dependency) {
784 if (classMap.containsKey(element)) {
785 MSAttributeObject value = classMap.get(element);
787 StringUtils.replaceEach(value.getDependency(), new String[] {"[", "]"}, new String[] {"", ""});
788 workingList = new ArrayList<>(Arrays.asList(rawValue.split(",")));
789 for (String depend : workingList) {
790 if (!returnList.contains(depend) && !depend.isEmpty()) {
791 returnList.add(depend.trim());
792 // getFullDepedency(workingList)
801 @RequestMapping(value = {"/get_MicroServiceHeaderDefaultsDataByName"}, method = {RequestMethod.GET},
802 produces = MediaType.APPLICATION_JSON_VALUE)
803 public void getMicroServiceHeaderDefaultsEntityDataByName(HttpServletResponse response) {
804 DictionaryUtils utils = getDictionaryUtilsInstance();
805 utils.getDataByEntity(response, microServiceHeaderDefaultDatas, "modelName", MicroserviceHeaderdeFaults.class);
808 @RequestMapping(value = {"/get_MicroServiceHeaderDefaultsData"}, method = {RequestMethod.GET},
809 produces = MediaType.APPLICATION_JSON_VALUE)
810 public void getMicroServiceHeaderDefaultsEntityData(HttpServletResponse response) {
811 DictionaryUtils utils = getDictionaryUtilsInstance();
812 utils.getData(response, microServiceHeaderDefaultDatas, MicroserviceHeaderdeFaults.class);
816 @RequestMapping(value = {"/ms_dictionary/save_headerDefaults"}, method = {RequestMethod.POST})
817 public ModelAndView saveMicroServiceHeaderDefaultValues(HttpServletRequest request, HttpServletResponse response)
819 DictionaryUtils utils = getDictionaryUtilsInstance();
821 boolean fromAPI = utils.isRequestFromAPI(request);
822 ObjectMapper mapper = new ObjectMapper();
823 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
824 JsonNode root = mapper.readTree(request.getReader());
826 MicroserviceHeaderdeFaults msHeaderdeFaults;
829 mapper.readValue(root.get(dictionaryFields).toString(), MicroserviceHeaderdeFaults.class);
831 msHeaderdeFaults = mapper.readValue(root.get("modelAttributeDictionaryData").toString(),
832 MicroserviceHeaderdeFaults.class);
835 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(msHeaderdeFaults.getModelName(),
836 "modelName", MicroserviceHeaderdeFaults.class);
837 boolean duplicateflag = false;
838 if (duplicateData != null && !duplicateData.isEmpty()) {
839 MicroserviceHeaderdeFaults data = (MicroserviceHeaderdeFaults) duplicateData.get(0);
840 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
841 msHeaderdeFaults.setId(data.getId());
842 } else if ((request.getParameter(operation) != null
843 && !"update".equals(request.getParameter(operation)))
844 || (request.getParameter(operation) == null && (data.getId() != msHeaderdeFaults.getId()))) {
845 duplicateflag = true;
849 String responseString = null;
850 if (!duplicateflag) {
851 if (msHeaderdeFaults.getId() == 0) {
852 commonClassDao.save(msHeaderdeFaults);
854 commonClassDao.update(msHeaderdeFaults);
856 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroserviceHeaderdeFaults.class));
858 responseString = duplicateResponseString;
861 return utils.getResultForApi(responseString);
863 utils.setResponseData(response, microServiceHeaderDefaultDatas, responseString);
865 } catch (Exception e) {
866 utils.setErrorResponseData(response, e);
871 @RequestMapping(value = {"/ms_dictionary/remove_headerDefaults"}, method = {RequestMethod.POST})
872 public void removeMicroServiceHeaderDefaults(HttpServletRequest request, HttpServletResponse response)
874 DictionaryUtils utils = getDictionaryUtilsInstance();
875 utils.removeData(request, response, microServiceHeaderDefaultDatas, MicroserviceHeaderdeFaults.class);