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 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";
  93
  94     public MicroServiceDictionaryController() {
  95         super();
  96     }
  97
  98     private DictionaryUtils getDictionaryUtilsInstance() {
  99         return DictionaryUtils.getDictionaryUtils();
 100     }
 101
 102     @Autowired
 103     public MicroServiceDictionaryController(CommonClassDao commonClassDao) {
 104         MicroServiceDictionaryController.commonClassDao = commonClassDao;
 105     }
 106
 107     public static void setCommonClassDao(CommonClassDao commonClassDao) {
 108         MicroServiceDictionaryController.commonClassDao = commonClassDao;
 109     }
 110
 111     MSModelUtils utils = new MSModelUtils(XACMLPapServlet.getMsOnapName(), XACMLPapServlet.getMsPolicyName());
 112
 113     private MicroServiceModels newModel;
 114
 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);
 120     }
 121
 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);
 127     }
 128
 129     @RequestMapping(value = {"/ms_dictionary/save_dcaeUUID"}, method = {RequestMethod.POST})
 130     public ModelAndView saveDCAEUUIDDictionary(HttpServletRequest request, HttpServletResponse response)
 131             throws IOException {
 132         DictionaryUtils utils = getDictionaryUtilsInstance();
 133         try {
 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());
 138             DCAEuuid dCAEuuid;
 139             if (fromAPI) {
 140                 dCAEuuid = mapper.readValue(root.get(dictionaryFields).toString(), DCAEuuid.class);
 141             } else {
 142                 dCAEuuid = mapper.readValue(root.get("dcaeUUIDDictionaryData").toString(), DCAEuuid.class);
 143             }
 144
 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;
 155                 }
 156             }
 157             String responseString = null;
 158             if (!duplicateflag) {
 159                 if (dCAEuuid.getId() == 0) {
 160                     commonClassDao.save(dCAEuuid);
 161                 } else {
 162                     commonClassDao.update(dCAEuuid);
 163                 }
 164                 responseString = mapper.writeValueAsString(commonClassDao.getData(DCAEuuid.class));
 165             } else {
 166                 responseString = duplicateResponseString;
 167             }
 168             if (fromAPI) {
 169                 return utils.getResultForApi(responseString);
 170             } else {
 171                 utils.setResponseData(response, dcaeUUIDDatas, responseString);
 172             }
 173         } catch (Exception e) {
 174             utils.setErrorResponseData(response, e);
 175         }
 176         return null;
 177     }
 178
 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);
 183     }
 184
 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);
 190     }
 191
 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);
 197     }
 198
 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);
 204     }
 205
 206     /**
 207      * Save dictionary data.
 208      *
 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.
 213      */
 214     // save_DictionaryData
 215     @RequestMapping(value = {"/ms_dictionary/save_DictionaryData"}, method = {RequestMethod.POST})
 216     public ModelAndView saveDictionaryData(HttpServletRequest request, HttpServletResponse response)
 217             throws IOException {
 218         DictionaryUtils dictUtil = getDictionaryUtilsInstance();
 219         try {
 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;
 225             if (fromApi) {
 226                 dictionaryData = mapper.readValue(root.get(dictionaryFields).toString(), DictionaryData.class);
 227             } else {
 228                 dictionaryData = mapper.readValue(root.get(MICROSERVICEDICTNAMEDATAS).toString(), DictionaryData.class);
 229             }
 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;
 241                 }
 242             }
 243             String responseString = null;
 244             if (!duplicateflag) {
 245                 if (dictionaryData.getId() == 0) {
 246                     commonClassDao.save(dictionaryData);
 247                 } else {
 248                     commonClassDao.update(dictionaryData);
 249                 }
 250                 responseString = mapper.writeValueAsString(commonClassDao.getData(DictionaryData.class));
 251             } else {
 252                 responseString = duplicateResponseString;
 253             }
 254             if (fromApi) {
 255                 return dictUtil.getResultForApi(responseString);
 256             } else {
 257                 dictUtil.setResponseData(response, MICROSERVICEDICTNAMEDATAS, responseString);
 258             }
 259         } catch (Exception e) {
 260             dictUtil.setErrorResponseData(response, e);
 261         }
 262         return null;
 263     }
 264
 265     @RequestMapping(value = {"/ms_dictionary/remove_msDictionaryData"}, method = {RequestMethod.POST})
 266     public void removeMicroServiceDictionaryData(HttpServletRequest request, HttpServletResponse response)
 267             throws IOException {
 268         DictionaryUtils utils = getDictionaryUtilsInstance();
 269         utils.removeData(request, response, MICROSERVICEDICTNAMEDATAS, DictionaryData.class);
 270     }
 271
 272     //
 273     @RequestMapping(value = {"/ms_dictionary/save_configName"}, method = {RequestMethod.POST})
 274     public ModelAndView saveMicroServiceConfigNameDictionary(HttpServletRequest request, HttpServletResponse response)
 275             throws IOException {
 276         DictionaryUtils utils = getDictionaryUtilsInstance();
 277         try {
 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;
 283             if (fromAPI) {
 284                 microServiceConfigName =
 285                         mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceConfigName.class);
 286             } else {
 287                 microServiceConfigName = mapper.readValue(root.get("microServiceConfigNameDictionaryData").toString(),
 288                         MicroServiceConfigName.class);
 289             }
 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;
 302                 }
 303             }
 304             String responseString = null;
 305             if (!duplicateflag) {
 306                 if (microServiceConfigName.getId() == 0) {
 307                     commonClassDao.save(microServiceConfigName);
 308                 } else {
 309                     commonClassDao.update(microServiceConfigName);
 310                 }
 311                 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceConfigName.class));
 312             } else {
 313                 responseString = duplicateResponseString;
 314             }
 315             if (fromAPI) {
 316                 return utils.getResultForApi(responseString);
 317             } else {
 318                 utils.setResponseData(response, microServiceConfigNameDatas, responseString);
 319             }
 320         } catch (Exception e) {
 321             utils.setErrorResponseData(response, e);
 322         }
 323         return null;
 324     }
 325
 326     @RequestMapping(value = {"/ms_dictionary/remove_msConfigName"}, method = {RequestMethod.POST})
 327     public void removeMicroServiceConfigNameDictionary(HttpServletRequest request, HttpServletResponse response)
 328             throws IOException {
 329         DictionaryUtils utils = getDictionaryUtilsInstance();
 330         utils.removeData(request, response, microServiceConfigNameDatas, MicroServiceConfigName.class);
 331     }
 332
 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);
 338     }
 339
 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);
 345     }
 346
 347     @RequestMapping(value = {"/ms_dictionary/save_location"}, method = {RequestMethod.POST})
 348     public ModelAndView saveMicroServiceLocationDictionary(HttpServletRequest request, HttpServletResponse response)
 349             throws IOException {
 350         DictionaryUtils utils = getDictionaryUtilsInstance();
 351         try {
 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;
 357             if (fromAPI) {
 358                 microServiceLocation =
 359                         mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceLocation.class);
 360             } else {
 361                 microServiceLocation = mapper.readValue(root.get("microServiceLocationDictionaryData").toString(),
 362                         MicroServiceLocation.class);
 363             }
 364
 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;
 377                 }
 378             }
 379             String responseString = null;
 380             if (!duplicateflag) {
 381                 if (microServiceLocation.getId() == 0) {
 382                     commonClassDao.save(microServiceLocation);
 383                 } else {
 384                     commonClassDao.update(microServiceLocation);
 385                 }
 386                 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceLocation.class));
 387             } else {
 388                 responseString = duplicateResponseString;
 389             }
 390             if (fromAPI) {
 391                 return utils.getResultForApi(responseString);
 392             } else {
 393                 utils.setResponseData(response, microServiceLocationDatas, responseString);
 394             }
 395         } catch (Exception e) {
 396             utils.setErrorResponseData(response, e);
 397         }
 398         return null;
 399     }
 400
 401     @RequestMapping(value = {"/ms_dictionary/remove_msLocation"}, method = {RequestMethod.POST})
 402     public void removeMicroServiceLocationDictionary(HttpServletRequest request, HttpServletResponse response)
 403             throws IOException {
 404         DictionaryUtils utils = getDictionaryUtilsInstance();
 405         utils.removeData(request, response, microServiceLocationDatas, MicroServiceLocation.class);
 406     }
 407
 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);
 413     }
 414
 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);
 420     }
 421
 422     @RequestMapping(value = {"/ms_dictionary/save_modelAttribute"}, method = {RequestMethod.POST})
 423     public ModelAndView saveMicroServiceAttributeDictionary(HttpServletRequest request, HttpServletResponse response)
 424             throws IOException {
 425         DictionaryUtils utils = getDictionaryUtilsInstance();
 426         try {
 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());
 431
 432             MicroServiceAttribute microServiceAttribute;
 433             String checkValue;
 434             if (fromAPI) {
 435                 microServiceAttribute =
 436                         mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceAttribute.class);
 437             } else {
 438                 microServiceAttribute = mapper.readValue(root.get("modelAttributeDictionaryData").toString(),
 439                         MicroServiceAttribute.class);
 440             }
 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;
 455                 }
 456             }
 457             String responseString = null;
 458             if (!duplicateflag) {
 459                 if (microServiceAttribute.getId() == 0) {
 460                     commonClassDao.save(microServiceAttribute);
 461                 } else {
 462                     commonClassDao.update(microServiceAttribute);
 463                 }
 464                 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceAttribute.class));
 465             } else {
 466                 responseString = duplicateResponseString;
 467             }
 468             if (fromAPI) {
 469                 return utils.getResultForApi(responseString);
 470             } else {
 471                 utils.setResponseData(response, microServiceAttributeDatas, responseString);
 472             }
 473         } catch (Exception e) {
 474             utils.setErrorResponseData(response, e);
 475         }
 476         return null;
 477     }
 478
 479     @RequestMapping(value = {"/ms_dictionary/remove_modelAttribute"}, method = {RequestMethod.POST})
 480     public void removeMicroServiceAttributeDictionary(HttpServletRequest request, HttpServletResponse response)
 481             throws IOException {
 482         DictionaryUtils utils = getDictionaryUtilsInstance();
 483         utils.removeData(request, response, microServiceAttributeDatas, MicroServiceAttribute.class);
 484     }
 485
 486
 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);
 492     }
 493
 494     @RequestMapping(value = {"/get_MicroServiceModelsDataByVersion"}, method = {RequestMethod.GET},
 495             produces = MediaType.APPLICATION_JSON_VALUE)
 496     public void getMicroServiceModelsDictionaryByVersionEntityData(HttpServletRequest request,
 497             HttpServletResponse response) {
 498         try {
 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("\"", "");
 505             }
 506             if (modelName != null) {
 507                 model.put(microServiceModelsDictionaryDatas, mapper.writeValueAsString(
 508                         commonClassDao.getDataById(MicroServiceModels.class, modelName, modelName)));
 509             } else {
 510                 model.put(errorMsg, "No model name given");
 511             }
 512             JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
 513             JSONObject j = new JSONObject(msg);
 514             response.getWriter().write(j.toString());
 515         } catch (Exception e) {
 516             LOGGER.error(e);
 517         }
 518     }
 519
 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);
 525     }
 526
 527     @RequestMapping(value = {"/get_MicroServiceModelsDataServiceVersion"}, method = {RequestMethod.GET},
 528             produces = MediaType.APPLICATION_JSON_VALUE)
 529     public void getMicroServiceModelsDictionaryEntityDataServiceVersion(HttpServletResponse response) {
 530         try {
 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());
 539                 }
 540             }
 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());
 547
 548         } catch (Exception e) {
 549             response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 550             response.addHeader("error", "dictionaryDBQuery");
 551             LOGGER.error(e);
 552         }
 553     }
 554
 555     @RequestMapping(value = {"/get_MicroServiceModelsDataByClass"}, method = {RequestMethod.GET},
 556             produces = MediaType.APPLICATION_JSON_VALUE)
 557     public void getMicroServiceModelsDictionaryClassEntityData(HttpServletResponse response) {
 558         try {
 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());
 567
 568         } catch (Exception e) {
 569             response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
 570             response.addHeader(errorMsg, dictionaryDBQuery);
 571             LOGGER.error(e);
 572         }
 573     }
 574
 575     @RequestMapping(value = {"/ms_dictionary/save_model"}, method = {RequestMethod.POST})
 576     public ModelAndView saveMicroServiceModelsDictionary(HttpServletRequest request, HttpServletResponse response)
 577             throws IOException {
 578         DictionaryUtils utils = getDictionaryUtilsInstance();
 579         try {
 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;
 587
 588             String dataOrderInfo = null;
 589             if (root.has("dataOrderInfo")) {
 590                 dataOrderInfo = root.get("dataOrderInfo").toString();
 591             }
 592
 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("\"", ""));
 601                         }
 602                         if (root.get(microServiceModelsDictionaryData).has(modelName)) {
 603                             microServiceModels.setModelName(root.get(microServiceModelsDictionaryData).get(modelName)
 604                                     .asText().replace("\"", ""));
 605                             this.newModel.setModelName(microServiceModels.getModelName());
 606                         }
 607                         if (root.get(microServiceModelsDictionaryData).has(version)) {
 608                             microServiceModels.setVersion(
 609                                     root.get(microServiceModelsDictionaryData).get(version).asText().replace("\"", ""));
 610                             this.newModel.setVersion(microServiceModels.getVersion());
 611                         }
 612                     }
 613
 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);
 627                     }
 628
 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("}", ""));
 643                     this.newModel
 644                             .setAnnotation(mainClass.getMatchingSet().toString().replace("{", "").replace("}", ""));
 645
 646                 } else {
 647                     if (fromAPI) {
 648                         microServiceModels =
 649                                 mapper.readValue(root.get(dictionaryFields).toString(), MicroServiceModels.class);
 650                         userId = "API";
 651                     } else {
 652                         if (root.has(microServiceModelsDictionaryData)) {
 653                             if (root.get(microServiceModelsDictionaryData).has(description)) {
 654                                 microServiceModels.setDescription(root.get(microServiceModelsDictionaryData)
 655                                         .get(description).asText().replace("\"", ""));
 656                             }
 657                             if (root.get(microServiceModelsDictionaryData).has(modelName)) {
 658                                 microServiceModels.setModelName(root.get(microServiceModelsDictionaryData)
 659                                         .get(modelName).asText().replace("\"", ""));
 660                                 this.newModel.setModelName(microServiceModels.getModelName());
 661                             }
 662                             if (root.get(microServiceModelsDictionaryData).has(version)) {
 663                                 microServiceModels.setVersion(root.get(microServiceModelsDictionaryData).get(version)
 664                                         .asText().replace("\"", ""));
 665                                 this.newModel.setVersion(microServiceModels.getVersion());
 666                             }
 667                         }
 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);
 680                             }
 681                         }
 682                         userId = root.get("userid").textValue();
 683                         addValuesToNewModel(classMap);
 684                     }
 685                 }
 686             }
 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);
 697             }
 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;
 710                 }
 711             }
 712             UserInfo userInfo = utils.getUserInfo(userId);
 713
 714             String responseString = null;
 715             if (!duplicateflag) {
 716                 microServiceModels.setUserCreatedBy(userInfo);
 717                 if (microServiceModels.getId() == 0) {
 718                     commonClassDao.save(microServiceModels);
 719                 } else {
 720                     commonClassDao.update(microServiceModels);
 721                 }
 722                 responseString = mapper.writeValueAsString(commonClassDao.getData(PrefixList.class));
 723             } else {
 724                 responseString = duplicateResponseString;
 725             }
 726             if (fromAPI) {
 727                 return utils.getResultForApi(responseString);
 728             } else {
 729                 utils.setResponseData(response, microServiceModelsDictionaryDatas, responseString);
 730             }
 731         } catch (Exception e) {
 732             utils.setErrorResponseData(response, e);
 733         }
 734         return null;
 735     }
 736
 737     @RequestMapping(value = {"/ms_dictionary/remove_msModel"}, method = {RequestMethod.POST})
 738     public void removeMicroServiceModelsDictionary(HttpServletRequest request, HttpServletResponse response)
 739             throws IOException {
 740         DictionaryUtils utils = getDictionaryUtilsInstance();
 741         utils.removeData(request, response, microServiceModelsDictionaryDatas, MicroServiceModels.class);
 742     }
 743
 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;
 747
 748         MSAttributeObject mainClass = classMap.get(this.newModel.getModelName());
 749
 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);
 757                 if (temp != null) {
 758                     mainClass.addAllRefAttribute(temp.getRefAttribute());
 759                     mainClass.addAllAttribute(temp.getAttribute());
 760                 }
 761             }
 762             subAttribute = utils.createSubAttributes(dependency, classMap, this.newModel.getModelName());
 763         } else {
 764             subAttribute = "{}";
 765             this.newModel.setDependency("");
 766         }
 767
 768         if (mainClass != null && mainClass.getDependency() == null) {
 769             mainClass.setDependency("");
 770         }
 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("}", ""));
 778         }
 779     }
 780
 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);
 788                 String rawValue =
 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)
 795                     }
 796                 }
 797             }
 798         }
 799
 800         return returnList;
 801     }
 802
 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);
 808     }
 809
 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);
 815     }
 816
 817
 818     @RequestMapping(value = {"/ms_dictionary/save_headerDefaults"}, method = {RequestMethod.POST})
 819     public ModelAndView saveMicroServiceHeaderDefaultValues(HttpServletRequest request, HttpServletResponse response)
 820             throws IOException {
 821         DictionaryUtils utils = getDictionaryUtilsInstance();
 822         try {
 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());
 827
 828             MicroserviceHeaderdeFaults msHeaderdeFaults;
 829             if (fromAPI) {
 830                 msHeaderdeFaults =
 831                         mapper.readValue(root.get(dictionaryFields).toString(), MicroserviceHeaderdeFaults.class);
 832             } else {
 833                 msHeaderdeFaults = mapper.readValue(root.get("modelAttributeDictionaryData").toString(),
 834                         MicroserviceHeaderdeFaults.class);
 835             }
 836
 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;
 848                 }
 849             }
 850
 851             String responseString = null;
 852             if (!duplicateflag) {
 853                 if (msHeaderdeFaults.getId() == 0) {
 854                     commonClassDao.save(msHeaderdeFaults);
 855                 } else {
 856                     commonClassDao.update(msHeaderdeFaults);
 857                 }
 858                 responseString = mapper.writeValueAsString(commonClassDao.getData(MicroserviceHeaderdeFaults.class));
 859             } else {
 860                 responseString = duplicateResponseString;
 861             }
 862             if (fromAPI) {
 863                 return utils.getResultForApi(responseString);
 864             } else {
 865                 utils.setResponseData(response, microServiceHeaderDefaultDatas, responseString);
 866             }
 867         } catch (Exception e) {
 868             utils.setErrorResponseData(response, e);
 869         }
 870         return null;
 871     }
 872
 873     @RequestMapping(value = {"/ms_dictionary/remove_headerDefaults"}, method = {RequestMethod.POST})
 874     public void removeMicroServiceHeaderDefaults(HttpServletRequest request, HttpServletResponse response)
 875             throws IOException {
 876         DictionaryUtils utils = getDictionaryUtilsInstance();
 877         utils.removeData(request, response, microServiceHeaderDefaultDatas, MicroserviceHeaderdeFaults.class);
 878     }
 879 }