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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP-PAP-REST
   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
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.pap.xacml.rest.controller;
  22
  23 import 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;
  33 import java.util.Map;
  34 import java.util.Set;
  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;
  62
  63 @Controller
  64 public class MicroServiceDictionaryController {
  65     private static final Logger LOGGER = FlexLogger.getLogger(MicroServiceDictionaryController.class);
  66
  67     private static CommonClassDao commonClassDao;
  68
  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";
  91
  92     public MicroServiceDictionaryController() {
  93         super();
  94     }
  95
  96     private DictionaryUtils getDictionaryUtilsInstance() {
  97         return DictionaryUtils.getDictionaryUtils();
  98     }
  99
 100     @Autowired
 101     public MicroServiceDictionaryController(CommonClassDao commonClassDao) {
 102         MicroServiceDictionaryController.commonClassDao = commonClassDao;
 103     }
 104
 105     public static void setCommonClassDao(CommonClassDao commonClassDao) {
 106         MicroServiceDictionaryController.commonClassDao = commonClassDao;
 107     }
 108
 109     MSModelUtils utils = new MSModelUtils(XACMLPapServlet.getMsOnapName(), XACMLPapServlet.getMsPolicyName());
 110
 111     private MicroServiceModels newModel;
 112
 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);
 118     }
 119
 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);
 125     }
 126
 127     @RequestMapping(value = {"/ms_dictionary/save_dcaeUUID"}, method = {RequestMethod.POST})
 128     public ModelAndView saveDCAEUUIDDictionary(HttpServletRequest request, HttpServletResponse response)
 129             throws IOException {
 130         DictionaryUtils utils = getDictionaryUtilsInstance();
 131         try {
 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());
 136             DCAEuuid dCAEuuid;
 137             if (fromAPI) {
 138                 dCAEuuid = mapper.readValue(root.get(dictionaryFields).toString(), DCAEuuid.class);
 139             } else {
 140                 dCAEuuid = mapper.readValue(root.get("dcaeUUIDDictionaryData").toString(), DCAEuuid.class);
 141             }
 142
 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;
 153                 }
 154             }
 155             String responseString = null;
 156             if (!duplicateflag) {
 157                 if (dCAEuuid.getId() == 0) {
 158                     commonClassDao.save(dCAEuuid);
 159                 } else {
 160                     commonClassDao.update(dCAEuuid);
 161                 }
 162                 responseString = mapper.writeValueAsString(commonClassDao.getData(DCAEuuid.class));
 163             } else {
 164                 responseString = duplicateResponseString;
 165             }
 166             if (fromAPI) {
 167                 return utils.getResultForApi(responseString);
 168             } else {
 169                 utils.setResponseData(response, dcaeUUIDDatas, responseString);
 170             }
 171         } catch (Exception e) {
 172             utils.setErrorResponseData(response, e);
 173         }
 174         return null;
 175     }
 176
 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);
 181     }
 182
 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);
 188     }
 189
 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);
 195     }
 196
 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);
 202     }
 203
 204     /**
 205      * Save dictionary data.
 206      *
 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.
 211      */
 212     // save_DictionaryData
 213     @RequestMapping(value = {"/ms_dictionary/save_DictionaryData"}, method = {RequestMethod.POST})
 214     public ModelAndView saveDictionaryData(HttpServletRequest request, HttpServletResponse response)
 215             throws IOException {
 216         DictionaryUtils dictUtil = getDictionaryUtilsInstance();
 217         try {
 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;
 223             if (fromApi) {
 224                 dictionaryData = mapper.readValue(root.get(dictionaryFields).toString(), DictionaryData.class);
 225             } else {
 226                 dictionaryData = mapper.readValue(root.get(MICROSERVICEDICTNAMEDATAS).toString(), DictionaryData.class);
 227             }
 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;
 239                 }
 240             }
 241             String responseString = null;
 242             if (!duplicateflag) {
 243                 if (dictionaryData.getId() == 0) {
 244                     commonClassDao.save(dictionaryData);
 245                 } else {
 246                     commonClassDao.update(dictionaryData);
 247                 }
 248                 responseString = mapper.writeValueAsString(commonClassDao.getData(DictionaryData.class));
 249             } else {
 250                 responseString = duplicateResponseString;
 251             }
 252             if (fromApi) {
 253                 return dictUtil.getResultForApi(responseString);
 254             } else {
 255                 dictUtil.setResponseData(response, MICROSERVICEDICTNAMEDATAS, responseString);
 256             }
 257         } catch (Exception e) {
 258             dictUtil.setErrorResponseData(response, e);
 259         }
 260         return null;
 261     }
 262
 263     @RequestMapping(value = {"/ms_dictionary/remove_msDictionaryData"}, method = {RequestMethod.POST})
 264     public void removeMicroServiceDictionaryData(HttpServletRequest request, HttpServletResponse response)
 265             throws IOException {
 266         DictionaryUtils utils = getDictionaryUtilsInstance();
 267         utils.removeData(request, response, MICROSERVICEDICTNAMEDATAS, DictionaryData.class);
 268     }
 269
 270     //
 271     @RequestMapping(value = {"/ms_dictionary/save_configName"}, method = {RequestMethod.POST})
 272     public ModelAndView saveMicroServiceConfigNameDictionary(HttpServletRequest request, HttpServletResponse response)
 273             throws IOException {
 274         DictionaryUtils utils = getDictionaryUtilsInstance();
 275         try {
 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;
 281             if (fromAPI) {
 282                 microServiceConfigName =
 283                         mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceConfigName.class);
 284             } else {
 285                 microServiceConfigName = mapper.readValue(root.get("microServiceConfigNameDictionaryData").toString(),
 286                         MicroServiceConfigName.class);
 287             }
 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;
 300                 }
 301             }
 302             String responseString = null;
 303             if (!duplicateflag) {
 304                 if (microServiceConfigName.getId() == 0) {
 305                     commonClassDao.save(microServiceConfigName);
 306                 } else {
 307                     commonClassDao.update(microServiceConfigName);
 308                 }
 309                 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceConfigName.class));
 310             } else {
 311                 responseString = duplicateResponseString;
 312             }
 313             if (fromAPI) {
 314                 return utils.getResultForApi(responseString);
 315             } else {
 316                 utils.setResponseData(response, microServiceConfigNameDatas, responseString);
 317             }
 318         } catch (Exception e) {
 319             utils.setErrorResponseData(response, e);
 320         }
 321         return null;
 322     }
 323
 324     @RequestMapping(value = {"/ms_dictionary/remove_msConfigName"}, method = {RequestMethod.POST})
 325     public void removeMicroServiceConfigNameDictionary(HttpServletRequest request, HttpServletResponse response)
 326             throws IOException {
 327         DictionaryUtils utils = getDictionaryUtilsInstance();
 328         utils.removeData(request, response, microServiceConfigNameDatas, MicroServiceConfigName.class);
 329     }
 330
 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);
 336     }
 337
 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);
 343     }
 344
 345     @RequestMapping(value = {"/ms_dictionary/save_location"}, method = {RequestMethod.POST})
 346     public ModelAndView saveMicroServiceLocationDictionary(HttpServletRequest request, HttpServletResponse response)
 347             throws IOException {
 348         DictionaryUtils utils = getDictionaryUtilsInstance();
 349         try {
 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;
 355             if (fromAPI) {
 356                 microServiceLocation =
 357                         mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceLocation.class);
 358             } else {
 359                 microServiceLocation = mapper.readValue(root.get("microServiceLocationDictionaryData").toString(),
 360                         MicroServiceLocation.class);
 361             }
 362
 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;
 375                 }
 376             }
 377             String responseString = null;
 378             if (!duplicateflag) {
 379                 if (microServiceLocation.getId() == 0) {
 380                     commonClassDao.save(microServiceLocation);
 381                 } else {
 382                     commonClassDao.update(microServiceLocation);
 383                 }
 384                 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceLocation.class));
 385             } else {
 386                 responseString = duplicateResponseString;
 387             }
 388             if (fromAPI) {
 389                 return utils.getResultForApi(responseString);
 390             } else {
 391                 utils.setResponseData(response, microServiceLocationDatas, responseString);
 392             }
 393         } catch (Exception e) {
 394             utils.setErrorResponseData(response, e);
 395         }
 396         return null;
 397     }
 398
 399     @RequestMapping(value = {"/ms_dictionary/remove_msLocation"}, method = {RequestMethod.POST})
 400     public void removeMicroServiceLocationDictionary(HttpServletRequest request, HttpServletResponse response)
 401             throws IOException {
 402         DictionaryUtils utils = getDictionaryUtilsInstance();
 403         utils.removeData(request, response, microServiceLocationDatas, MicroServiceLocation.class);
 404     }
 405
 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);
 411     }
 412
 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);
 418     }
 419
 420     @RequestMapping(value = {"/ms_dictionary/save_modelAttribute"}, method = {RequestMethod.POST})
 421     public ModelAndView saveMicroServiceAttributeDictionary(HttpServletRequest request, HttpServletResponse response)
 422             throws IOException {
 423         DictionaryUtils utils = getDictionaryUtilsInstance();
 424         try {
 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());
 429
 430             MicroServiceAttribute microServiceAttribute;
 431             String checkValue;
 432             if (fromAPI) {
 433                 microServiceAttribute =
 434                         mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceAttribute.class);
 435             } else {
 436                 microServiceAttribute = mapper.readValue(root.get("modelAttributeDictionaryData").toString(),
 437                         MicroServiceAttribute.class);
 438             }
 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;
 453                 }
 454             }
 455             String responseString = null;
 456             if (!duplicateflag) {
 457                 if (microServiceAttribute.getId() == 0) {
 458                     commonClassDao.save(microServiceAttribute);
 459                 } else {
 460                     commonClassDao.update(microServiceAttribute);
 461                 }
 462                 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceAttribute.class));
 463             } else {
 464                 responseString = duplicateResponseString;
 465             }
 466             if (fromAPI) {
 467                 return utils.getResultForApi(responseString);
 468             } else {
 469                 utils.setResponseData(response, microServiceAttributeDatas, responseString);
 470             }
 471         } catch (Exception e) {
 472             utils.setErrorResponseData(response, e);
 473         }
 474         return null;
 475     }
 476
 477     @RequestMapping(value = {"/ms_dictionary/remove_modelAttribute"}, method = {RequestMethod.POST})
 478     public void removeMicroServiceAttributeDictionary(HttpServletRequest request, HttpServletResponse response)
 479             throws IOException {
 480         DictionaryUtils utils = getDictionaryUtilsInstance();
 481         utils.removeData(request, response, microServiceAttributeDatas, MicroServiceAttribute.class);
 482     }
 483
 484
 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);
 490     }
 491
 492     @RequestMapping(value = {"/get_MicroServiceModelsDataByVersion"}, method = {RequestMethod.GET},
 493             produces = MediaType.APPLICATION_JSON_VALUE)
 494     public void getMicroServiceModelsDictionaryByVersionEntityData(HttpServletRequest request,
 495             HttpServletResponse response) {
 496         try {
 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("\"", "");
 503             }
 504             if (modelName != null) {
 505                 model.put(microServiceModelsDictionaryDatas, mapper.writeValueAsString(
 506                         commonClassDao.getDataById(MicroServiceModels.class, modelName, modelName)));
 507             } else {
 508                 model.put(errorMsg, "No model name given");
 509             }
 510             JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
 511             JSONObject j = new JSONObject(msg);
 512             response.getWriter().write(j.toString());
 513         } catch (Exception e) {
 514             LOGGER.error(e);
 515         }
 516     }
 517
 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);
 523     }
 524
 525     @RequestMapping(value = {"/get_MicroServiceModelsDataServiceVersion"}, method = {RequestMethod.GET},
 526             produces = MediaType.APPLICATION_JSON_VALUE)
 527     public void getMicroServiceModelsDictionaryEntityDataServiceVersion(HttpServletResponse response) {
 528         try {
 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());
 537                 }
 538             }
 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());
 545
 546         } catch (Exception e) {
 547             response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 548             response.addHeader("error", "dictionaryDBQuery");
 549             LOGGER.error(e);
 550         }
 551     }
 552
 553     @RequestMapping(value = {"/get_MicroServiceModelsDataByClass"}, method = {RequestMethod.GET},
 554             produces = MediaType.APPLICATION_JSON_VALUE)
 555     public void getMicroServiceModelsDictionaryClassEntityData(HttpServletResponse response) {
 556         try {
 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());
 565
 566         } catch (Exception e) {
 567             response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 568             response.addHeader(errorMsg, dictionaryDBQuery);
 569             LOGGER.error(e);
 570         }
 571     }
 572
 573     @RequestMapping(value = {"/ms_dictionary/save_model"}, method = {RequestMethod.POST})
 574     public ModelAndView saveMicroServiceModelsDictionary(HttpServletRequest request, HttpServletResponse response)
 575             throws IOException {
 576         DictionaryUtils utils = getDictionaryUtilsInstance();
 577         try {
 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;
 585
 586             String dataOrderInfo = null;
 587             if (root.has("dataOrderInfo")) {
 588                 dataOrderInfo = root.get("dataOrderInfo").toString();
 589             }
 590
 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("\"", ""));
 599                         }
 600                         if (root.get(microServiceModelsDictionaryData).has(modelName)) {
 601                             microServiceModels.setModelName(root.get(microServiceModelsDictionaryData).get(modelName)
 602                                     .asText().replace("\"", ""));
 603                             this.newModel.setModelName(microServiceModels.getModelName());
 604                         }
 605                         if (root.get(microServiceModelsDictionaryData).has(version)) {
 606                             microServiceModels.setVersion(
 607                                     root.get(microServiceModelsDictionaryData).get(version).asText().replace("\"", ""));
 608                             this.newModel.setVersion(microServiceModels.getVersion());
 609                         }
 610                     }
 611
 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);
 625                     }
 626
 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("}", ""));
 641                     this.newModel
 642                             .setAnnotation(mainClass.getMatchingSet().toString().replace("{", "").replace("}", ""));
 643
 644                 } else {
 645                     if (fromAPI) {
 646                         microServiceModels =
 647                                 mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceModels.class);
 648                         userId = "API";
 649                     } else {
 650                         if (root.has(microServiceModelsDictionaryData)) {
 651                             if (root.get(microServiceModelsDictionaryData).has(description)) {
 652                                 microServiceModels.setDescription(root.get(microServiceModelsDictionaryData)
 653                                         .get(description).asText().replace("\"", ""));
 654                             }
 655                             if (root.get(microServiceModelsDictionaryData).has(modelName)) {
 656                                 microServiceModels.setModelName(root.get(microServiceModelsDictionaryData)
 657                                         .get(modelName).asText().replace("\"", ""));
 658                                 this.newModel.setModelName(microServiceModels.getModelName());
 659                             }
 660                             if (root.get(microServiceModelsDictionaryData).has(version)) {
 661                                 microServiceModels.setVersion(root.get(microServiceModelsDictionaryData).get(version)
 662                                         .asText().replace("\"", ""));
 663                                 this.newModel.setVersion(microServiceModels.getVersion());
 664                             }
 665                         }
 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);
 678                             }
 679                         }
 680                         userId = root.get("userid").textValue();
 681                         addValuesToNewModel(classMap);
 682                     }
 683                 }
 684             }
 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);
 695             }
 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;
 708                 }
 709             }
 710             UserInfo userInfo = utils.getUserInfo(userId);
 711
 712             String responseString = null;
 713             if (!duplicateflag) {
 714                 microServiceModels.setUserCreatedBy(userInfo);
 715                 if (microServiceModels.getId() == 0) {
 716                     commonClassDao.save(microServiceModels);
 717                 } else {
 718                     commonClassDao.update(microServiceModels);
 719                 }
 720                 responseString = mapper.writeValueAsString(commonClassDao.getData(PrefixList.class));
 721             } else {
 722                 responseString = duplicateResponseString;
 723             }
 724             if (fromAPI) {
 725                 return utils.getResultForApi(responseString);
 726             } else {
 727                 utils.setResponseData(response, microServiceModelsDictionaryDatas, responseString);
 728             }
 729         } catch (Exception e) {
 730             utils.setErrorResponseData(response, e);
 731         }
 732         return null;
 733     }
 734
 735     @RequestMapping(value = {"/ms_dictionary/remove_msModel"}, method = {RequestMethod.POST})
 736     public void removeMicroServiceModelsDictionary(HttpServletRequest request, HttpServletResponse response)
 737             throws IOException {
 738         DictionaryUtils utils = getDictionaryUtilsInstance();
 739         utils.removeData(request, response, microServiceModelsDictionaryDatas, MicroServiceModels.class);
 740     }
 741
 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;
 745
 746         MSAttributeObject mainClass = classMap.get(this.newModel.getModelName());
 747
 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);
 755                 if (temp != null) {
 756                     mainClass.addAllRefAttribute(temp.getRefAttribute());
 757                     mainClass.addAllAttribute(temp.getAttribute());
 758                 }
 759             }
 760             subAttribute = utils.createSubAttributes(dependency, classMap, this.newModel.getModelName());
 761         } else {
 762             subAttribute = "{}";
 763             this.newModel.setDependency("");
 764         }
 765
 766         if (mainClass != null && mainClass.getDependency() == null) {
 767             mainClass.setDependency("");
 768         }
 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("}", ""));
 776         }
 777     }
 778
 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);
 786                 String rawValue =
 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)
 793                     }
 794                 }
 795             }
 796         }
 797
 798         return returnList;
 799     }
 800
 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);
 806     }
 807
 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);
 813     }
 814
 815
 816     @RequestMapping(value = {"/ms_dictionary/save_headerDefaults"}, method = {RequestMethod.POST})
 817     public ModelAndView saveMicroServiceHeaderDefaultValues(HttpServletRequest request, HttpServletResponse response)
 818             throws IOException {
 819         DictionaryUtils utils = getDictionaryUtilsInstance();
 820         try {
 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());
 825
 826             MicroserviceHeaderdeFaults msHeaderdeFaults;
 827             if (fromAPI) {
 828                 msHeaderdeFaults =
 829                         mapper.readValue(root.get(dictionaryFields).toString(), MicroserviceHeaderdeFaults.class);
 830             } else {
 831                 msHeaderdeFaults = mapper.readValue(root.get("modelAttributeDictionaryData").toString(),
 832                         MicroserviceHeaderdeFaults.class);
 833             }
 834
 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;
 846                 }
 847             }
 848
 849             String responseString = null;
 850             if (!duplicateflag) {
 851                 if (msHeaderdeFaults.getId() == 0) {
 852                     commonClassDao.save(msHeaderdeFaults);
 853                 } else {
 854                     commonClassDao.update(msHeaderdeFaults);
 855                 }
 856                 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroserviceHeaderdeFaults.class));
 857             } else {
 858                 responseString = duplicateResponseString;
 859             }
 860             if (fromAPI) {
 861                 return utils.getResultForApi(responseString);
 862             } else {
 863                 utils.setResponseData(response, microServiceHeaderDefaultDatas, responseString);
 864             }
 865         } catch (Exception e) {
 866             utils.setErrorResponseData(response, e);
 867         }
 868         return null;
 869     }
 870
 871     @RequestMapping(value = {"/ms_dictionary/remove_headerDefaults"}, method = {RequestMethod.POST})
 872     public void removeMicroServiceHeaderDefaults(HttpServletRequest request, HttpServletResponse response)
 873             throws IOException {
 874         DictionaryUtils utils = getDictionaryUtilsInstance();
 875         utils.removeData(request, response, microServiceHeaderDefaultDatas, MicroserviceHeaderdeFaults.class);
 876     }
 877 }