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 apiflag = "apiflag";
78 private static String dictionaryFields = "dictionaryFields";
79 private static String update = "update";
80 private static String duplicateResponseString = "Duplicate";
81 private static String microServiceModelsDictionaryDatas = "microServiceModelsDictionaryDatas";
82 private static String modelName = "modelName";
83 private static String microServiceModelsDictionaryData = "microServiceModelsDictionaryData";
84 private static String description = "description";
85 private static String version = "version";
86 private static String classMapData = "classMap";
87 private static String dcaeUUIDDatas = "dcaeUUIDDictionaryDatas";
88 private static String microServiceConfigNameDatas = "microServiceConfigNameDictionaryDatas";
89 private static String microServiceLocationDatas = "microServiceLocationDictionaryDatas";
90 private static String microServiceAttributeDatas = "microServiceAttributeDictionaryDatas";
91 private static String microServiceHeaderDefaultDatas = "microServiceHeaderDefaultDatas";
92 private static final String MICROSERVICEDICTNAMEDATAS = "microServiceDictionaryDatas";
94 public MicroServiceDictionaryController() {
98 private DictionaryUtils getDictionaryUtilsInstance() {
99 return DictionaryUtils.getDictionaryUtils();
103 public MicroServiceDictionaryController(CommonClassDao commonClassDao) {
104 MicroServiceDictionaryController.commonClassDao = commonClassDao;
107 public static void setCommonClassDao(CommonClassDao commonClassDao) {
108 MicroServiceDictionaryController.commonClassDao = commonClassDao;
111 MSModelUtils utils = new MSModelUtils(XACMLPapServlet.getMsOnapName(), XACMLPapServlet.getMsPolicyName());
113 private MicroServiceModels newModel;
115 @RequestMapping(value = {"/get_DCAEUUIDDataByName"}, method = {RequestMethod.GET},
116 produces = MediaType.APPLICATION_JSON_VALUE)
117 public void getDCAEUUIDDictionaryByNameEntityData(HttpServletResponse response) {
118 DictionaryUtils utils = getDictionaryUtilsInstance();
119 utils.getDataByEntity(response, dcaeUUIDDatas, "name", DCAEuuid.class);
122 @RequestMapping(value = {"/get_DCAEUUIDData"}, method = {RequestMethod.GET},
123 produces = MediaType.APPLICATION_JSON_VALUE)
124 public void getDCAEUUIDDictionaryEntityData(HttpServletResponse response) {
125 DictionaryUtils utils = getDictionaryUtilsInstance();
126 utils.getData(response, dcaeUUIDDatas, DCAEuuid.class);
129 @RequestMapping(value = {"/ms_dictionary/save_dcaeUUID"}, method = {RequestMethod.POST})
130 public ModelAndView saveDCAEUUIDDictionary(HttpServletRequest request, HttpServletResponse response)
132 DictionaryUtils utils = getDictionaryUtilsInstance();
134 boolean fromAPI = utils.isRequestFromAPI(request);
135 ObjectMapper mapper = new ObjectMapper();
136 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
137 JsonNode root = mapper.readTree(request.getReader());
140 dCAEuuid = mapper.readValue(root.get(dictionaryFields).toString(), DCAEuuid.class);
142 dCAEuuid = mapper.readValue(root.get("dcaeUUIDDictionaryData").toString(), DCAEuuid.class);
145 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(dCAEuuid.getName(), "name", DCAEuuid.class);
146 boolean duplicateflag = false;
147 if (duplicateData != null && !duplicateData.isEmpty()) {
148 DCAEuuid data = (DCAEuuid) duplicateData.get(0);
149 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
150 dCAEuuid.setId(data.getId());
151 } else if ((request.getParameter(operation) != null
152 && !"update".equals(request.getParameter(operation)))
153 || (request.getParameter(operation) == null && (data.getId() != dCAEuuid.getId()))) {
154 duplicateflag = true;
157 String responseString = null;
158 if (!duplicateflag) {
159 if (dCAEuuid.getId() == 0) {
160 commonClassDao.save(dCAEuuid);
162 commonClassDao.update(dCAEuuid);
164 responseString = mapper.writeValueAsString(commonClassDao.getData(DCAEuuid.class));
166 responseString = duplicateResponseString;
169 return utils.getResultForApi(responseString);
171 utils.setResponseData(response, dcaeUUIDDatas, responseString);
173 } catch (Exception e) {
174 utils.setErrorResponseData(response, e);
179 @RequestMapping(value = {"/ms_dictionary/remove_dcaeuuid"}, method = {RequestMethod.POST})
180 public void removeDCAEUUIDDictionary(HttpServletRequest request, HttpServletResponse response) throws IOException {
181 DictionaryUtils utils = getDictionaryUtilsInstance();
182 utils.removeData(request, response, dcaeUUIDDatas, DCAEuuid.class);
185 @RequestMapping(value = {"/get_MicroServiceConfigNameDataByName"}, method = {RequestMethod.GET},
186 produces = MediaType.APPLICATION_JSON_VALUE)
187 public void getMicroServiceConfigNameByNameDictionaryEntityData(HttpServletResponse response) {
188 DictionaryUtils utils = getDictionaryUtilsInstance();
189 utils.getDataByEntity(response, microServiceConfigNameDatas, "name", MicroServiceConfigName.class);
192 @RequestMapping(value = {"/get_MicroServiceConfigNameData"}, method = {RequestMethod.GET},
193 produces = MediaType.APPLICATION_JSON_VALUE)
194 public void getMicroServiceConfigNameDictionaryEntityData(HttpServletResponse response) {
195 DictionaryUtils utils = getDictionaryUtilsInstance();
196 utils.getData(response, microServiceConfigNameDatas, MicroServiceConfigName.class);
199 @RequestMapping(value = {"/get_MicroServiceDictData"}, method = {RequestMethod.GET},
200 produces = MediaType.APPLICATION_JSON_VALUE)
201 public void getMicroServiceDictNameDictionaryEntityData(HttpServletResponse response) {
202 DictionaryUtils utils = getDictionaryUtilsInstance();
203 utils.getData(response, MICROSERVICEDICTNAMEDATAS, DictionaryData.class);
207 * Save dictionary data.
209 * @param request the request
210 * @param response the response
211 * @return the model and view
212 * @throws IOException Signals that an I/O exception has occurred.
214 // save_DictionaryData
215 @RequestMapping(value = {"/ms_dictionary/save_DictionaryData"}, method = {RequestMethod.POST})
216 public ModelAndView saveDictionaryData(HttpServletRequest request, HttpServletResponse response)
218 DictionaryUtils dictUtil = getDictionaryUtilsInstance();
220 boolean fromApi = dictUtil.isRequestFromAPI(request);
221 ObjectMapper mapper = new ObjectMapper();
222 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
223 JsonNode root = mapper.readTree(request.getReader());
224 DictionaryData dictionaryData;
226 dictionaryData = mapper.readValue(root.get(dictionaryFields).toString(), DictionaryData.class);
228 dictionaryData = mapper.readValue(root.get(MICROSERVICEDICTNAMEDATAS).toString(), DictionaryData.class);
230 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(dictionaryData.getDictionaryName(),
231 "dictionaryName", DictionaryData.class);
232 boolean duplicateflag = false;
233 if (duplicateData != null && !duplicateData.isEmpty()) {
234 DictionaryData data = (DictionaryData) duplicateData.get(0);
235 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
236 dictionaryData.setId(data.getId());
237 } else if ((request.getParameter(operation) != null
238 && !"update".equals(request.getParameter(operation)))
239 || (request.getParameter(operation) == null && (data.getId() != dictionaryData.getId()))) {
240 duplicateflag = true;
243 String responseString = null;
244 if (!duplicateflag) {
245 if (dictionaryData.getId() == 0) {
246 commonClassDao.save(dictionaryData);
248 commonClassDao.update(dictionaryData);
250 responseString = mapper.writeValueAsString(commonClassDao.getData(DictionaryData.class));
252 responseString = duplicateResponseString;
255 return dictUtil.getResultForApi(responseString);
257 dictUtil.setResponseData(response, MICROSERVICEDICTNAMEDATAS, responseString);
259 } catch (Exception e) {
260 dictUtil.setErrorResponseData(response, e);
265 @RequestMapping(value = {"/ms_dictionary/remove_msDictionaryData"}, method = {RequestMethod.POST})
266 public void removeMicroServiceDictionaryData(HttpServletRequest request, HttpServletResponse response)
268 DictionaryUtils utils = getDictionaryUtilsInstance();
269 utils.removeData(request, response, MICROSERVICEDICTNAMEDATAS, DictionaryData.class);
273 @RequestMapping(value = {"/ms_dictionary/save_configName"}, method = {RequestMethod.POST})
274 public ModelAndView saveMicroServiceConfigNameDictionary(HttpServletRequest request, HttpServletResponse response)
276 DictionaryUtils utils = getDictionaryUtilsInstance();
278 boolean fromAPI = utils.isRequestFromAPI(request);
279 ObjectMapper mapper = new ObjectMapper();
280 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
281 JsonNode root = mapper.readTree(request.getReader());
282 MicroServiceConfigName microServiceConfigName;
284 microServiceConfigName =
285 mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceConfigName.class);
287 microServiceConfigName = mapper.readValue(root.get("microServiceConfigNameDictionaryData").toString(),
288 MicroServiceConfigName.class);
290 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(microServiceConfigName.getName(), "name",
291 MicroServiceConfigName.class);
292 boolean duplicateflag = false;
293 if (duplicateData != null && !duplicateData.isEmpty()) {
294 MicroServiceConfigName data = (MicroServiceConfigName) duplicateData.get(0);
295 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
296 microServiceConfigName.setId(data.getId());
297 } else if ((request.getParameter(operation) != null
298 && !"update".equals(request.getParameter(operation)))
299 || (request.getParameter(operation) == null
300 && (data.getId() != microServiceConfigName.getId()))) {
301 duplicateflag = true;
304 String responseString = null;
305 if (!duplicateflag) {
306 if (microServiceConfigName.getId() == 0) {
307 commonClassDao.save(microServiceConfigName);
309 commonClassDao.update(microServiceConfigName);
311 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceConfigName.class));
313 responseString = duplicateResponseString;
316 return utils.getResultForApi(responseString);
318 utils.setResponseData(response, microServiceConfigNameDatas, responseString);
320 } catch (Exception e) {
321 utils.setErrorResponseData(response, e);
326 @RequestMapping(value = {"/ms_dictionary/remove_msConfigName"}, method = {RequestMethod.POST})
327 public void removeMicroServiceConfigNameDictionary(HttpServletRequest request, HttpServletResponse response)
329 DictionaryUtils utils = getDictionaryUtilsInstance();
330 utils.removeData(request, response, microServiceConfigNameDatas, MicroServiceConfigName.class);
333 @RequestMapping(value = {"/get_MicroServiceLocationDataByName"}, method = {RequestMethod.GET},
334 produces = MediaType.APPLICATION_JSON_VALUE)
335 public void getMicroServiceLocationByNameDictionaryEntityData(HttpServletResponse response) {
336 DictionaryUtils utils = getDictionaryUtilsInstance();
337 utils.getDataByEntity(response, microServiceLocationDatas, "name", MicroServiceLocation.class);
340 @RequestMapping(value = {"/get_MicroServiceLocationData"}, method = {RequestMethod.GET},
341 produces = MediaType.APPLICATION_JSON_VALUE)
342 public void getMicroServiceLocationDictionaryEntityData(HttpServletResponse response) {
343 DictionaryUtils utils = getDictionaryUtilsInstance();
344 utils.getData(response, microServiceLocationDatas, MicroServiceLocation.class);
347 @RequestMapping(value = {"/ms_dictionary/save_location"}, method = {RequestMethod.POST})
348 public ModelAndView saveMicroServiceLocationDictionary(HttpServletRequest request, HttpServletResponse response)
350 DictionaryUtils utils = getDictionaryUtilsInstance();
352 boolean fromAPI = utils.isRequestFromAPI(request);
353 ObjectMapper mapper = new ObjectMapper();
354 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
355 JsonNode root = mapper.readTree(request.getReader());
356 MicroServiceLocation microServiceLocation;
358 microServiceLocation =
359 mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceLocation.class);
361 microServiceLocation = mapper.readValue(root.get("microServiceLocationDictionaryData").toString(),
362 MicroServiceLocation.class);
365 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(microServiceLocation.getName(), "name",
366 MicroServiceLocation.class);
367 boolean duplicateflag = false;
368 if (duplicateData != null && !duplicateData.isEmpty()) {
369 MicroServiceLocation data = (MicroServiceLocation) duplicateData.get(0);
370 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
371 microServiceLocation.setId(data.getId());
372 } else if ((request.getParameter(operation) != null
373 && !"update".equals(request.getParameter(operation)))
374 || (request.getParameter(operation) == null
375 && (data.getId() != microServiceLocation.getId()))) {
376 duplicateflag = true;
379 String responseString = null;
380 if (!duplicateflag) {
381 if (microServiceLocation.getId() == 0) {
382 commonClassDao.save(microServiceLocation);
384 commonClassDao.update(microServiceLocation);
386 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceLocation.class));
388 responseString = duplicateResponseString;
391 return utils.getResultForApi(responseString);
393 utils.setResponseData(response, microServiceLocationDatas, responseString);
395 } catch (Exception e) {
396 utils.setErrorResponseData(response, e);
401 @RequestMapping(value = {"/ms_dictionary/remove_msLocation"}, method = {RequestMethod.POST})
402 public void removeMicroServiceLocationDictionary(HttpServletRequest request, HttpServletResponse response)
404 DictionaryUtils utils = getDictionaryUtilsInstance();
405 utils.removeData(request, response, microServiceLocationDatas, MicroServiceLocation.class);
408 @RequestMapping(value = {"/get_MicroServiceAttributeDataByName"}, method = {RequestMethod.GET},
409 produces = MediaType.APPLICATION_JSON_VALUE)
410 public void getMicroServiceAttributeByNameDictionaryEntityData(HttpServletResponse response) {
411 DictionaryUtils utils = getDictionaryUtilsInstance();
412 utils.getDataByEntity(response, microServiceAttributeDatas, "name", MicroServiceAttribute.class);
415 @RequestMapping(value = {"/get_MicroServiceAttributeData"}, method = {RequestMethod.GET},
416 produces = MediaType.APPLICATION_JSON_VALUE)
417 public void getMicroServiceAttributeDictionaryEntityData(HttpServletResponse response) {
418 DictionaryUtils utils = getDictionaryUtilsInstance();
419 utils.getData(response, microServiceAttributeDatas, MicroServiceAttribute.class);
422 @RequestMapping(value = {"/ms_dictionary/save_modelAttribute"}, method = {RequestMethod.POST})
423 public ModelAndView saveMicroServiceAttributeDictionary(HttpServletRequest request, HttpServletResponse response)
425 DictionaryUtils utils = getDictionaryUtilsInstance();
427 boolean fromAPI = utils.isRequestFromAPI(request);
428 ObjectMapper mapper = new ObjectMapper();
429 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
430 JsonNode root = mapper.readTree(request.getReader());
432 MicroServiceAttribute microServiceAttribute;
435 microServiceAttribute =
436 mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceAttribute.class);
438 microServiceAttribute = mapper.readValue(root.get("modelAttributeDictionaryData").toString(),
439 MicroServiceAttribute.class);
441 checkValue = microServiceAttribute.getName() + ":" + microServiceAttribute.getValue() + ":"
442 + microServiceAttribute.getModelName();
443 List<Object> duplicateData =
444 commonClassDao.checkDuplicateEntry(checkValue, "name:value:modelName", MicroServiceAttribute.class);
445 boolean duplicateflag = false;
446 if (duplicateData != null && !duplicateData.isEmpty()) {
447 MicroServiceAttribute data = (MicroServiceAttribute) duplicateData.get(0);
448 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
449 microServiceAttribute.setId(data.getId());
450 } else if ((request.getParameter(operation) != null
451 && !"update".equals(request.getParameter(operation)))
452 || (request.getParameter(operation) == null
453 && (data.getId() != microServiceAttribute.getId()))) {
454 duplicateflag = true;
457 String responseString = null;
458 if (!duplicateflag) {
459 if (microServiceAttribute.getId() == 0) {
460 commonClassDao.save(microServiceAttribute);
462 commonClassDao.update(microServiceAttribute);
464 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceAttribute.class));
466 responseString = duplicateResponseString;
469 return utils.getResultForApi(responseString);
471 utils.setResponseData(response, microServiceAttributeDatas, responseString);
473 } catch (Exception e) {
474 utils.setErrorResponseData(response, e);
479 @RequestMapping(value = {"/ms_dictionary/remove_modelAttribute"}, method = {RequestMethod.POST})
480 public void removeMicroServiceAttributeDictionary(HttpServletRequest request, HttpServletResponse response)
482 DictionaryUtils utils = getDictionaryUtilsInstance();
483 utils.removeData(request, response, microServiceAttributeDatas, MicroServiceAttribute.class);
487 @RequestMapping(value = {"/get_MicroServiceModelsDataByName"}, method = {RequestMethod.GET},
488 produces = MediaType.APPLICATION_JSON_VALUE)
489 public void getMicroServiceModelsDictionaryByNameEntityData(HttpServletResponse response) {
490 DictionaryUtils utils = getDictionaryUtilsInstance();
491 utils.getDataByEntity(response, microServiceModelsDictionaryDatas, modelName, MicroServiceModels.class);
494 @RequestMapping(value = {"/get_MicroServiceModelsDataByVersion"}, method = {RequestMethod.GET},
495 produces = MediaType.APPLICATION_JSON_VALUE)
496 public void getMicroServiceModelsDictionaryByVersionEntityData(HttpServletRequest request,
497 HttpServletResponse response) {
499 Map<String, Object> model = new HashMap<>();
500 ObjectMapper mapper = new ObjectMapper();
501 JsonNode root = mapper.readTree(request.getReader());
502 String modelName = null;
503 if (root.get(microServiceModelsDictionaryData).has(modelName)) {
504 modelName = root.get(microServiceModelsDictionaryData).get(modelName).asText().replace("\"", "");
506 if (modelName != null) {
507 model.put(microServiceModelsDictionaryDatas, mapper.writeValueAsString(
508 commonClassDao.getDataById(MicroServiceModels.class, modelName, modelName)));
510 model.put(errorMsg, "No model name given");
512 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
513 JSONObject j = new JSONObject(msg);
514 response.getWriter().write(j.toString());
515 } catch (Exception e) {
520 @RequestMapping(value = {"/get_MicroServiceModelsData"}, method = {RequestMethod.GET},
521 produces = MediaType.APPLICATION_JSON_VALUE)
522 public void getMicroServiceModelsDictionaryEntityData(HttpServletResponse response) {
523 DictionaryUtils utils = getDictionaryUtilsInstance();
524 utils.getData(response, microServiceModelsDictionaryDatas, MicroServiceModels.class);
527 @RequestMapping(value = {"/get_MicroServiceModelsDataServiceVersion"}, method = {RequestMethod.GET},
528 produces = MediaType.APPLICATION_JSON_VALUE)
529 public void getMicroServiceModelsDictionaryEntityDataServiceVersion(HttpServletResponse response) {
531 Map<String, Object> model = new HashMap<>();
532 ObjectMapper mapper = new ObjectMapper();
533 List<String> data = new ArrayList<>();
534 List<Object> datas = commonClassDao.getData(MicroServiceModels.class);
535 for (int i = 0; i < datas.size(); i++) {
536 MicroServiceModels msmodel = (MicroServiceModels) datas.get(i);
537 if (!data.contains(msmodel.getModelName())) {
538 data.add(msmodel.getModelName() + "-v" + msmodel.getVersion());
541 model.put(microServiceModelsDictionaryDatas, mapper.writeValueAsString(data));
542 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
543 JSONObject j = new JSONObject(msg);
544 response.addHeader("successMapKey", "success");
545 response.addHeader("operation", "getDictionary");
546 response.getWriter().write(j.toString());
548 } catch (Exception e) {
549 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
550 response.addHeader("error", "dictionaryDBQuery");
555 @RequestMapping(value = {"/get_MicroServiceModelsDataByClass"}, method = {RequestMethod.GET},
556 produces = MediaType.APPLICATION_JSON_VALUE)
557 public void getMicroServiceModelsDictionaryClassEntityData(HttpServletResponse response) {
559 Map<String, Object> model = new HashMap<>();
560 ObjectMapper mapper = new ObjectMapper();
561 model.put("microServiceModelsDictionaryClassDatas", mapper.writeValueAsString(modelList));
562 JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
563 JSONObject j = new JSONObject(msg);
564 response.addHeader(successMapKey, successMsg);
565 response.addHeader(operation, getDictionary);
566 response.getWriter().write(j.toString());
568 } catch (Exception e) {
569 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
570 response.addHeader(errorMsg, dictionaryDBQuery);
575 @RequestMapping(value = {"/ms_dictionary/save_model"}, method = {RequestMethod.POST})
576 public ModelAndView saveMicroServiceModelsDictionary(HttpServletRequest request, HttpServletResponse response)
578 DictionaryUtils utils = getDictionaryUtilsInstance();
580 this.newModel = new MicroServiceModels();
581 boolean fromAPI = utils.isRequestFromAPI(request);
582 ObjectMapper mapper = new ObjectMapper();
583 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
584 JsonNode root = mapper.readTree(request.getReader());
585 MicroServiceModels microServiceModels = new MicroServiceModels();
586 String userId = null;
588 String dataOrderInfo = null;
589 if (root.has("dataOrderInfo")) {
590 dataOrderInfo = root.get("dataOrderInfo").toString();
593 if (root.has("modelType")) {
594 JsonNode dataType = root.get("modelType");
595 String modelType = dataType.toString();
596 if (modelType.contains("yml")) {
597 if (root.has(microServiceModelsDictionaryData)) {
598 if (root.get(microServiceModelsDictionaryData).has(description)) {
599 microServiceModels.setDescription(root.get(microServiceModelsDictionaryData)
600 .get(description).asText().replace("\"", ""));
602 if (root.get(microServiceModelsDictionaryData).has(modelName)) {
603 microServiceModels.setModelName(root.get(microServiceModelsDictionaryData).get(modelName)
604 .asText().replace("\"", ""));
605 this.newModel.setModelName(microServiceModels.getModelName());
607 if (root.get(microServiceModelsDictionaryData).has(version)) {
608 microServiceModels.setVersion(
609 root.get(microServiceModelsDictionaryData).get(version).asText().replace("\"", ""));
610 this.newModel.setVersion(microServiceModels.getVersion());
614 classMap = new LinkedHashMap<>();
615 JsonNode data = root.get(classMapData);
616 ObjectMapper mapper1 = new ObjectMapper();
617 String data1 = data.toString().substring(1, data.toString().length() - 1);
618 data1 = data1.replace("\\", "");
619 data1 = data1.replace("\"{", "{");
620 data1 = data1.replace("}\"", "}");
621 JSONObject jsonObject = new JSONObject(data1);
622 Set<String> keys = jsonObject.keySet();
623 for (String key : keys) {
624 String value = jsonObject.get(key).toString();
625 MSAttributeObject msAttributeObject = mapper1.readValue(value, MSAttributeObject.class);
626 classMap.put(key, msAttributeObject);
629 userId = root.get("userid").textValue();
630 MSAttributeObject mainClass = classMap.get(this.newModel.getModelName());
631 this.newModel.setDependency("[]");
632 String value = new Gson().toJson(mainClass.getSubClass());
633 this.newModel.setSub_attributes(value);
634 String attributes = mainClass.getAttribute().toString().replace("{", "").replace("}", "");
635 int equalsIndexForAttributes = attributes.indexOf('=');
636 String atttributesAfterFirstEquals = attributes.substring(equalsIndexForAttributes + 1);
637 this.newModel.setAttributes(atttributesAfterFirstEquals);
638 String refAttributes = mainClass.getRefAttribute().toString().replace("{", "").replace("}", "");
639 int equalsIndex = refAttributes.indexOf("=");
640 String refAttributesAfterFirstEquals = refAttributes.substring(equalsIndex + 1);
641 this.newModel.setRef_attributes(refAttributesAfterFirstEquals);
642 this.newModel.setEnumValues(mainClass.getEnumType().toString().replace("{", "").replace("}", ""));
644 .setAnnotation(mainClass.getMatchingSet().toString().replace("{", "").replace("}", ""));
649 mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceModels.class);
652 if (root.has(microServiceModelsDictionaryData)) {
653 if (root.get(microServiceModelsDictionaryData).has(description)) {
654 microServiceModels.setDescription(root.get(microServiceModelsDictionaryData)
655 .get(description).asText().replace("\"", ""));
657 if (root.get(microServiceModelsDictionaryData).has(modelName)) {
658 microServiceModels.setModelName(root.get(microServiceModelsDictionaryData)
659 .get(modelName).asText().replace("\"", ""));
660 this.newModel.setModelName(microServiceModels.getModelName());
662 if (root.get(microServiceModelsDictionaryData).has(version)) {
663 microServiceModels.setVersion(root.get(microServiceModelsDictionaryData).get(version)
664 .asText().replace("\"", ""));
665 this.newModel.setVersion(microServiceModels.getVersion());
668 if (root.has(classMapData)) {
669 classMap = new LinkedHashMap<>();
670 JsonNode data = root.get(classMapData);
671 ObjectMapper mapper1 = new ObjectMapper();
672 String data1 = data.toString().substring(1, data.toString().length() - 1);
673 data1 = data1.replace("\\", "");
674 JSONObject jsonObject = new JSONObject(data1);
675 Set<String> keys = jsonObject.keySet();
676 for (String key : keys) {
677 String value = jsonObject.get(key).toString();
678 MSAttributeObject msAttributeObject = mapper1.readValue(value, MSAttributeObject.class);
679 classMap.put(key, msAttributeObject);
682 userId = root.get("userid").textValue();
683 addValuesToNewModel(classMap);
687 microServiceModels.setAttributes(this.newModel.getAttributes());
688 microServiceModels.setRef_attributes(this.newModel.getRef_attributes());
689 microServiceModels.setDependency(this.newModel.getDependency());
690 microServiceModels.setModelName(this.newModel.getModelName());
691 microServiceModels.setSub_attributes(this.newModel.getSub_attributes());
692 microServiceModels.setVersion(this.newModel.getVersion());
693 microServiceModels.setEnumValues(this.newModel.getEnumValues());
694 microServiceModels.setAnnotation(this.newModel.getAnnotation());
695 if (dataOrderInfo != null) {
696 microServiceModels.setDataOrderInfo(dataOrderInfo);
698 String checkName = microServiceModels.getModelName() + ":" + microServiceModels.getVersion();
699 List<Object> duplicateData =
700 commonClassDao.checkDuplicateEntry(checkName, "modelName:version", MicroServiceModels.class);
701 boolean duplicateflag = false;
702 if (duplicateData != null && !duplicateData.isEmpty()) {
703 MicroServiceModels data = (MicroServiceModels) duplicateData.get(0);
704 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
705 microServiceModels.setId(data.getId());
706 } else if ((request.getParameter(operation) != null
707 && !"update".equals(request.getParameter(operation)))
708 || (request.getParameter(operation) == null && (data.getId() != microServiceModels.getId()))) {
709 duplicateflag = true;
712 UserInfo userInfo = utils.getUserInfo(userId);
714 String responseString = null;
715 if (!duplicateflag) {
716 microServiceModels.setUserCreatedBy(userInfo);
717 if (microServiceModels.getId() == 0) {
718 commonClassDao.save(microServiceModels);
720 commonClassDao.update(microServiceModels);
722 responseString = mapper.writeValueAsString(commonClassDao.getData(PrefixList.class));
724 responseString = duplicateResponseString;
727 return utils.getResultForApi(responseString);
729 utils.setResponseData(response, microServiceModelsDictionaryDatas, responseString);
731 } catch (Exception e) {
732 utils.setErrorResponseData(response, e);
737 @RequestMapping(value = {"/ms_dictionary/remove_msModel"}, method = {RequestMethod.POST})
738 public void removeMicroServiceModelsDictionary(HttpServletRequest request, HttpServletResponse response)
740 DictionaryUtils utils = getDictionaryUtilsInstance();
741 utils.removeData(request, response, microServiceModelsDictionaryDatas, MicroServiceModels.class);
744 private void addValuesToNewModel(HashMap<String, MSAttributeObject> classMap) {
745 // Loop through the classmap and pull out the required info for the new file.
746 String subAttribute = null;
748 MSAttributeObject mainClass = classMap.get(this.newModel.getModelName());
750 if (mainClass != null) {
751 String dependTemp = StringUtils.replaceEach(mainClass.getDependency(), new String[] {"[", "]", " "},
752 new String[] {"", "", ""});
753 ArrayList<String> dependency = new ArrayList<>(Arrays.asList(dependTemp.split(",")));
754 dependency = getFullDependencyList(dependency);
755 for (String element : dependency) {
756 MSAttributeObject temp = classMap.get(element);
758 mainClass.addAllRefAttribute(temp.getRefAttribute());
759 mainClass.addAllAttribute(temp.getAttribute());
762 subAttribute = utils.createSubAttributes(dependency, classMap, this.newModel.getModelName());
765 this.newModel.setDependency("");
768 if (mainClass != null && mainClass.getDependency() == null) {
769 mainClass.setDependency("");
771 if (mainClass != null) {
772 this.newModel.setDependency(mainClass.getDependency());
773 this.newModel.setSub_attributes(subAttribute);
774 this.newModel.setAttributes(mainClass.getAttribute().toString().replace("{", "").replace("}", ""));
775 this.newModel.setRef_attributes(mainClass.getRefAttribute().toString().replace("{", "").replace("}", ""));
776 this.newModel.setEnumValues(mainClass.getEnumType().toString().replace("{", "").replace("}", ""));
777 this.newModel.setAnnotation(mainClass.getMatchingSet().toString().replace("{", "").replace("}", ""));
781 private ArrayList<String> getFullDependencyList(ArrayList<String> dependency) {
782 ArrayList<String> returnList = new ArrayList<>();
783 ArrayList<String> workingList = new ArrayList<>();
784 returnList.addAll(dependency);
785 for (String element : dependency) {
786 if (classMap.containsKey(element)) {
787 MSAttributeObject value = classMap.get(element);
789 StringUtils.replaceEach(value.getDependency(), new String[] {"[", "]"}, new String[] {"", ""});
790 workingList = new ArrayList<>(Arrays.asList(rawValue.split(",")));
791 for (String depend : workingList) {
792 if (!returnList.contains(depend) && !depend.isEmpty()) {
793 returnList.add(depend.trim());
794 // getFullDepedency(workingList)
803 @RequestMapping(value = {"/get_MicroServiceHeaderDefaultsDataByName"}, method = {RequestMethod.GET},
804 produces = MediaType.APPLICATION_JSON_VALUE)
805 public void getMicroServiceHeaderDefaultsEntityDataByName(HttpServletResponse response) {
806 DictionaryUtils utils = getDictionaryUtilsInstance();
807 utils.getDataByEntity(response, microServiceHeaderDefaultDatas, "modelName", MicroserviceHeaderdeFaults.class);
810 @RequestMapping(value = {"/get_MicroServiceHeaderDefaultsData"}, method = {RequestMethod.GET},
811 produces = MediaType.APPLICATION_JSON_VALUE)
812 public void getMicroServiceHeaderDefaultsEntityData(HttpServletResponse response) {
813 DictionaryUtils utils = getDictionaryUtilsInstance();
814 utils.getData(response, microServiceHeaderDefaultDatas, MicroserviceHeaderdeFaults.class);
818 @RequestMapping(value = {"/ms_dictionary/save_headerDefaults"}, method = {RequestMethod.POST})
819 public ModelAndView saveMicroServiceHeaderDefaultValues(HttpServletRequest request, HttpServletResponse response)
821 DictionaryUtils utils = getDictionaryUtilsInstance();
823 boolean fromAPI = utils.isRequestFromAPI(request);
824 ObjectMapper mapper = new ObjectMapper();
825 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
826 JsonNode root = mapper.readTree(request.getReader());
828 MicroserviceHeaderdeFaults msHeaderdeFaults;
831 mapper.readValue(root.get(dictionaryFields).toString(), MicroserviceHeaderdeFaults.class);
833 msHeaderdeFaults = mapper.readValue(root.get("modelAttributeDictionaryData").toString(),
834 MicroserviceHeaderdeFaults.class);
837 List<Object> duplicateData = commonClassDao.checkDuplicateEntry(msHeaderdeFaults.getModelName(),
838 "modelName", MicroserviceHeaderdeFaults.class);
839 boolean duplicateflag = false;
840 if (duplicateData != null && !duplicateData.isEmpty()) {
841 MicroserviceHeaderdeFaults data = (MicroserviceHeaderdeFaults) duplicateData.get(0);
842 if (request.getParameter(operation) != null && "update".equals(request.getParameter(operation))) {
843 msHeaderdeFaults.setId(data.getId());
844 } else if ((request.getParameter(operation) != null
845 && !"update".equals(request.getParameter(operation)))
846 || (request.getParameter(operation) == null && (data.getId() != msHeaderdeFaults.getId()))) {
847 duplicateflag = true;
851 String responseString = null;
852 if (!duplicateflag) {
853 if (msHeaderdeFaults.getId() == 0) {
854 commonClassDao.save(msHeaderdeFaults);
856 commonClassDao.update(msHeaderdeFaults);
858 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroserviceHeaderdeFaults.class));
860 responseString = duplicateResponseString;
863 return utils.getResultForApi(responseString);
865 utils.setResponseData(response, microServiceHeaderDefaultDatas, responseString);
867 } catch (Exception e) {
868 utils.setErrorResponseData(response, e);
873 @RequestMapping(value = {"/ms_dictionary/remove_headerDefaults"}, method = {RequestMethod.POST})
874 public void removeMicroServiceHeaderDefaults(HttpServletRequest request, HttpServletResponse response)
876 DictionaryUtils utils = getDictionaryUtilsInstance();
877 utils.removeData(request, response, microServiceHeaderDefaultDatas, MicroserviceHeaderdeFaults.class);