gerrit.onap Code Review - sdnc/apps.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SDNC
   4  * ================================================================================
   5  * Copyright (C) 2020 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.sdnc.apps.ms.gra.controllers;
  22
  23 import com.fasterxml.jackson.annotation.JsonInclude;
  24 import com.fasterxml.jackson.core.JsonProcessingException;
  25 import com.fasterxml.jackson.databind.ObjectMapper;
  26 import org.onap.ccsdk.apps.services.RestApplicationException;
  27 import org.onap.ccsdk.apps.services.RestException;
  28 import org.onap.ccsdk.apps.services.RestProtocolError;
  29 import org.onap.ccsdk.apps.services.RestProtocolException;
  30 import org.onap.sdnc.apps.ms.gra.data.ConfigPreloadData;
  31 import org.onap.sdnc.apps.ms.gra.data.ConfigPreloadDataRepository;
  32 import org.onap.sdnc.apps.ms.gra.data.ConfigServices;
  33 import org.onap.sdnc.apps.ms.gra.data.ConfigServicesRepository;
  34 import org.onap.sdnc.apps.ms.gra.swagger.ConfigApi;
  35 import org.onap.sdnc.apps.ms.gra.swagger.model.*;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38 import org.springframework.beans.factory.annotation.Autowired;
  39 import org.springframework.boot.autoconfigure.domain.EntityScan;
  40 import org.springframework.context.annotation.ComponentScan;
  41 import org.springframework.http.HttpStatus;
  42 import org.springframework.http.ResponseEntity;
  43 import org.springframework.stereotype.Controller;
  44
  45 import javax.servlet.http.HttpServletRequest;
  46 import javax.validation.Valid;
  47 import java.util.ArrayList;
  48 import java.util.Iterator;
  49 import java.util.LinkedList;
  50 import java.util.List;
  51 import java.util.Optional;
  52 import java.util.concurrent.atomic.AtomicBoolean;
  53 import java.util.stream.Collectors;
  54 import java.util.stream.Stream;
  55
  56 @Controller
  57 @ComponentScan(basePackages = {"org.onap.sdnc.apps.ms.gra.*"})
  58 @EntityScan("org.onap.sdnc.apps.ms.gra.springboot.*")
  59 public class ConfigApiController implements ConfigApi {
  60     private static final Logger log = LoggerFactory.getLogger(ConfigApiController.class);
  61
  62     private final ObjectMapper objectMapper;
  63
  64     private final HttpServletRequest request;
  65
  66     @Autowired
  67     private ConfigPreloadDataRepository configPreloadDataRepository;
  68
  69     @Autowired
  70     private ConfigServicesRepository configServicesRepository;
  71
  72     @Autowired
  73     public ConfigApiController(ObjectMapper objectMapper, HttpServletRequest request) {
  74         objectMapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
  75         objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
  76         this.objectMapper = objectMapper;
  77         this.request = request;
  78     }
  79
  80     @Override
  81     public Optional<ObjectMapper> getObjectMapper() {
  82         return Optional.ofNullable(objectMapper);
  83     }
  84
  85     @Override
  86     public Optional<HttpServletRequest> getRequest() {
  87         return Optional.ofNullable(request);
  88     }
  89
  90     @Override
  91     public ResponseEntity<Void> configGENERICRESOURCEAPIpreloadInformationDelete() {
  92         configPreloadDataRepository.deleteAll();
  93         return (new ResponseEntity<>(HttpStatus.NO_CONTENT));
  94     }
  95
  96     @Override
  97     public ResponseEntity<GenericResourceApiPreloadModelInformation> configGENERICRESOURCEAPIpreloadInformationGet() throws RestApplicationException {
  98         GenericResourceApiPreloadModelInformation genericResourceApiPreloadModelInformation = new GenericResourceApiPreloadModelInformation();
  99
 100         if (configPreloadDataRepository.count() == 0) {
 101             throw new RestApplicationException("data-missing", "Request could not be completed because the relevant data model content does not exist", HttpStatus.NOT_FOUND.value());
 102         }
 103
 104         for (ConfigPreloadData configPreloadData : configPreloadDataRepository.findAll()) {
 105             GenericResourceApiPreloadmodelinformationPreloadList preloadListItem = new GenericResourceApiPreloadmodelinformationPreloadList();
 106
 107             preloadListItem.setPreloadId(configPreloadData.getPreloadId());
 108             preloadListItem.setPreloadType(configPreloadData.getPreloadType());
 109             try {
 110                 preloadListItem.setPreloadData(objectMapper.readValue(configPreloadData.getPreloadData(), GenericResourceApiPreloaddataPreloadData.class));
 111             } catch (JsonProcessingException e) {
 112                 log.error("Could not convert preload data", e);
 113                 throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 114             }
 115             genericResourceApiPreloadModelInformation.addPreloadListItem(preloadListItem);
 116         }
 117
 118
 119         return new ResponseEntity<>(genericResourceApiPreloadModelInformation, HttpStatus.OK);
 120     }
 121
 122     @Override
 123     public ResponseEntity<Void> configGENERICRESOURCEAPIpreloadInformationPost(@Valid GenericResourceApiPreloadModelInformation graPreloadModelInfo) throws RestApplicationException, RestProtocolException {
 124
 125         List<GenericResourceApiPreloadmodelinformationPreloadList> preloadList = graPreloadModelInfo.getPreloadList();
 126         List<ConfigPreloadData> newPreloadData = new LinkedList<>();
 127
 128         if (preloadList != null) {
 129             // Verification pass - if any items already exist, return an error
 130             for (GenericResourceApiPreloadmodelinformationPreloadList curItem : preloadList) {
 131
 132                 List<ConfigPreloadData> curPreloadData = configPreloadDataRepository.findByPreloadIdAndPreloadType(curItem.getPreloadId(), curItem.getPreloadType());
 133                 if ((curPreloadData != null) && (!curPreloadData.isEmpty())) {
 134                     log.error("Preload data already exists for {}:{}", curItem.getPreloadId(), curItem.getPreloadType());
 135                     throw new RestProtocolException("data-exists", "Data already exists for " + curItem.getPreloadId() + ":" + curItem.getPreloadType(), HttpStatus.CONFLICT.value());
 136                 } else {
 137                     try {
 138                         newPreloadData.add(new ConfigPreloadData(curItem.getPreloadId(), curItem.getPreloadType(), objectMapper.writeValueAsString(curItem.getPreloadData())));
 139                     } catch (JsonProcessingException e) {
 140                         log.error("Cannot convert preload data");
 141                         throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 142
 143                     }
 144                 }
 145             }
 146
 147             // Update pass
 148             for (ConfigPreloadData newDataItem : newPreloadData) {
 149                 log.info("Adding preload data for {}:{}", newDataItem.getPreloadId(), newDataItem.getPreloadType());
 150                 configPreloadDataRepository.save(newDataItem);
 151             }
 152         } else {
 153             throw new RestProtocolException("data-missing", "No preload-list entries found to add", HttpStatus.CONFLICT.value());
 154         }
 155
 156         return new ResponseEntity<>(HttpStatus.CREATED);
 157     }
 158
 159     @Override
 160     public ResponseEntity<Void> configGENERICRESOURCEAPIpreloadInformationPut(@Valid GenericResourceApiPreloadModelInformation graPreloadModelInfo) throws RestApplicationException {
 161
 162         boolean addedNew = false;
 163         List<GenericResourceApiPreloadmodelinformationPreloadList> preloadList = graPreloadModelInfo.getPreloadList();
 164
 165         if (preloadList != null) {
 166             Iterator<GenericResourceApiPreloadmodelinformationPreloadList> iter = preloadList.iterator();
 167             while (iter.hasNext()) {
 168                 GenericResourceApiPreloadmodelinformationPreloadList curItem = iter.next();
 169                 List<ConfigPreloadData> curPreloadData = configPreloadDataRepository.findByPreloadIdAndPreloadType(curItem.getPreloadId(), curItem.getPreloadType());
 170                 if ((curPreloadData == null) || curPreloadData.isEmpty()) {
 171                     addedNew = true;
 172                 }
 173
 174                 try {
 175                     configPreloadDataRepository.save(new ConfigPreloadData(curItem.getPreloadId(), curItem.getPreloadType(), objectMapper.writeValueAsString(curItem.getPreloadData())));
 176                 } catch (JsonProcessingException e) {
 177                     log.error("Cannot convert preload data", e);
 178                     throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 179
 180                 }
 181             }
 182         }
 183
 184         if (addedNew) {
 185             return new ResponseEntity<>(HttpStatus.CREATED);
 186         } else {
 187             return new ResponseEntity<>(HttpStatus.NO_CONTENT);
 188         }
 189
 190     }
 191
 192     @Override
 193     public ResponseEntity<Void> configGENERICRESOURCEAPIpreloadInformationPreloadListPost(@Valid GenericResourceApiPreloadmodelinformationPreloadList preloadListItem) throws RestProtocolException {
 194
 195         throw new RestProtocolException("data-missing", "Missing key for list \"preload-list\"", HttpStatus.NOT_FOUND.value());
 196     }
 197
 198
 199     @Override
 200     public ResponseEntity<Void> configGENERICRESOURCEAPIpreloadInformationPreloadListPreloadIdPreloadTypeDelete(String preloadId, String preloadType) {
 201         configPreloadDataRepository.deleteByPreloadIdAndPreloadType(preloadId, preloadType);
 202         return new ResponseEntity<>(HttpStatus.NO_CONTENT);
 203     }
 204
 205     @Override
 206     public ResponseEntity<GenericResourceApiPreloadmodelinformationPreloadList> configGENERICRESOURCEAPIpreloadInformationPreloadListPreloadIdPreloadTypeGet(String preloadId, String preloadType) throws RestApplicationException {
 207         List<ConfigPreloadData> preloadData = configPreloadDataRepository.findByPreloadIdAndPreloadType(preloadId, preloadType);
 208         if (preloadData != null) {
 209             if (!preloadData.isEmpty()) {
 210                 ConfigPreloadData preloadDataItem = preloadData.get(0);
 211                 GenericResourceApiPreloadmodelinformationPreloadList preloadDataList = new GenericResourceApiPreloadmodelinformationPreloadList();
 212                 preloadDataList.setPreloadId(preloadDataItem.getPreloadId());
 213                 preloadDataList.setPreloadType(preloadDataItem.getPreloadType());
 214                 try {
 215                     preloadDataList.setPreloadData(objectMapper.readValue(preloadDataItem.getPreloadData(), GenericResourceApiPreloaddataPreloadData.class));
 216                 } catch (JsonProcessingException e) {
 217                     log.error("Cannot convert preload data", e);
 218                     throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 219                 }
 220                 return new ResponseEntity<>(preloadDataList, HttpStatus.OK);
 221             }
 222         }
 223         return new ResponseEntity<>(HttpStatus.NOT_FOUND);
 224     }
 225
 226     @Override
 227     public ResponseEntity<Void> configGENERICRESOURCEAPIpreloadInformationPreloadListPreloadIdPreloadTypePost(String preloadId, String preloadType, @Valid GenericResourceApiPreloadmodelinformationPreloadList preloadListItem) throws RestApplicationException, RestProtocolException {
 228         List<ConfigPreloadData> preloadDataItems = configPreloadDataRepository.findByPreloadIdAndPreloadType(preloadId, preloadType);
 229
 230         if ((preloadDataItems != null) && !preloadDataItems.isEmpty()) {
 231             log.error("Preload data already exists for {}:{}", preloadId, preloadType);
 232             throw new RestProtocolException("data-exists", "Data already exists for " + preloadId + ":" + preloadType, HttpStatus.CONFLICT.value());
 233         }
 234
 235         try {
 236             log.info("Adding preload data for {}:{}", preloadId, preloadType);
 237             configPreloadDataRepository.save(new ConfigPreloadData(preloadId, preloadType, objectMapper.writeValueAsString(preloadListItem.getPreloadData())));
 238         } catch (JsonProcessingException e) {
 239             log.error("Cannot convert preload data", e);
 240             throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 241
 242         }
 243         return new ResponseEntity<>(HttpStatus.CREATED);
 244     }
 245
 246     @Override
 247     public ResponseEntity<Void> configGENERICRESOURCEAPIpreloadInformationPreloadListPreloadIdPreloadTypePut(String preloadId, String preloadType, @Valid GenericResourceApiPreloadmodelinformationPreloadList preloadListItem) throws RestApplicationException, RestProtocolException {
 248         List<ConfigPreloadData> preloadDataItems = configPreloadDataRepository.findByPreloadIdAndPreloadType(preloadId, preloadType);
 249         boolean dataExists = false;
 250         if ((preloadDataItems != null) && !preloadDataItems.isEmpty()) {
 251             dataExists = true;
 252         }
 253
 254         if ((preloadListItem.getPreloadId() == null) ||
 255                 (preloadListItem.getPreloadType() == null) ||
 256                 (preloadListItem.getPreloadData() == null)) {
 257             log.error("Invalid list item received: {}", preloadListItem);
 258             throw new RestProtocolException("bad-attribute", "Invalid data received", HttpStatus.BAD_REQUEST.value());
 259         }
 260
 261         try {
 262             if (dataExists) {
 263                 log.info("Updating preload data for {}:{} -> {}", preloadId, preloadType, objectMapper.writeValueAsString(preloadListItem));
 264
 265             } else {
 266                 log.info("Adding preload data for {}:{}", preloadId, preloadType);
 267             }
 268
 269             configPreloadDataRepository.save(new ConfigPreloadData(preloadId, preloadType, objectMapper.writeValueAsString(preloadListItem.getPreloadData())));
 270         } catch (JsonProcessingException e) {
 271             log.error("Cannot convert preload data", e);
 272             throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 273
 274         }
 275
 276         if (dataExists) {
 277             return new ResponseEntity<>(HttpStatus.NO_CONTENT);
 278         } else {
 279             return new ResponseEntity<>(HttpStatus.CREATED);
 280         }
 281     }
 282
 283
 284     @Override
 285     public ResponseEntity<Void> configGENERICRESOURCEAPIpreloadInformationPreloadListPreloadIdPreloadTypePreloadDataDelete(String preloadId, String preloadType) throws RestProtocolException {
 286         List<ConfigPreloadData> preloadData = configPreloadDataRepository.findByPreloadIdAndPreloadType(preloadId, preloadType);
 287
 288         if ((preloadData == null) || preloadData.isEmpty()) {
 289             throw new RestProtocolException("data-missing", "No preload entry found", HttpStatus.NOT_FOUND.value());
 290         }
 291
 292         ConfigPreloadData preloadDataItem = preloadData.get(0);
 293
 294         if (preloadDataItem.getPreloadData() == null) {
 295             throw new RestProtocolException("data-missing", "No preload-data found", HttpStatus.NOT_FOUND.value());
 296         }
 297         preloadDataItem.setPreloadData(null);
 298         configPreloadDataRepository.save(preloadDataItem);
 299
 300
 301         return new ResponseEntity<>(HttpStatus.NO_CONTENT);
 302     }
 303
 304
 305     @Override
 306     public ResponseEntity<GenericResourceApiPreloaddataPreloadData> configGENERICRESOURCEAPIpreloadInformationPreloadListPreloadIdPreloadTypePreloadDataGet(String preloadId, String preloadType) throws RestApplicationException, RestProtocolException {
 307         List<ConfigPreloadData> preloadData = configPreloadDataRepository.findByPreloadIdAndPreloadType(preloadId, preloadType);
 308
 309         if ((preloadData == null) || preloadData.isEmpty()) {
 310             throw new RestProtocolException("data-missing", "No preload entry found", HttpStatus.NOT_FOUND.value());
 311         }
 312
 313         ConfigPreloadData preloadDataItem = preloadData.get(0);
 314
 315         if (preloadDataItem.getPreloadData() == null) {
 316             throw new RestProtocolException("data-missing", "No preload-data found", HttpStatus.NOT_FOUND.value());
 317         }
 318         try {
 319             return new ResponseEntity<>(objectMapper.readValue(preloadDataItem.getPreloadData(), GenericResourceApiPreloaddataPreloadData.class), HttpStatus.OK);
 320         } catch (JsonProcessingException e) {
 321             log.error("Cannot convert preload data", e);
 322             throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 323         }
 324     }
 325
 326     @Override
 327     public ResponseEntity<Void> configGENERICRESOURCEAPIpreloadInformationPreloadListPreloadIdPreloadTypePreloadDataPost(String preloadId, String preloadType, @Valid GenericResourceApiPreloaddataPreloadData preloadData) throws RestApplicationException, RestProtocolException {
 328         List<ConfigPreloadData> preloadDataEntries = configPreloadDataRepository.findByPreloadIdAndPreloadType(preloadId, preloadType);
 329
 330         List<ConfigPreloadData> preloadDataItems = configPreloadDataRepository.findByPreloadIdAndPreloadType(preloadId, preloadType);
 331         if ((preloadDataItems == null) || (preloadDataItems.isEmpty())) {
 332             throw new RestProtocolException("data-missing", "No preload entry found", HttpStatus.NOT_FOUND.value());
 333         }
 334
 335         if ((preloadData == null) ||
 336                 (preloadData.getPreloadNetworkTopologyInformation() == null)) {
 337             throw new RestProtocolException("bad-attribute", "Invalid preloadData received", HttpStatus.BAD_REQUEST.value());
 338         }
 339
 340         ConfigPreloadData preloadDataItem = preloadDataItems.get(0);
 341
 342         if (preloadDataItem.getPreloadData() != null) {
 343             log.error("Preload data already exists for {}:{} ", preloadId, preloadType);
 344             throw new RestProtocolException("data-exists", "Data already exists for " + preloadId + ":" + preloadType, HttpStatus.CONFLICT.value());
 345         }
 346
 347         try {
 348             preloadDataItem.setPreloadData(objectMapper.writeValueAsString(preloadData));
 349             configPreloadDataRepository.save(preloadDataItem);
 350         } catch (JsonProcessingException e) {
 351             log.error("Cannot convert preload data", e);
 352             throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 353         }
 354
 355         return new ResponseEntity<>(HttpStatus.CREATED);
 356     }
 357
 358     @Override
 359     public ResponseEntity<Void> configGENERICRESOURCEAPIpreloadInformationPreloadListPreloadIdPreloadTypePreloadDataPut(String preloadId, String preloadType, @Valid GenericResourceApiPreloaddataPreloadData preloadData) throws RestApplicationException, RestProtocolException {
 360         boolean dataExists = false;
 361         List<ConfigPreloadData> preloadDataItems = configPreloadDataRepository.findByPreloadIdAndPreloadType(preloadId, preloadType);
 362         if ((preloadDataItems == null) || (preloadDataItems.isEmpty())) {
 363             throw new RestProtocolException("data-missing", "No preload entry found", HttpStatus.NOT_FOUND.value());
 364         }
 365
 366         if ((preloadData == null) ||
 367                 (preloadData.getPreloadNetworkTopologyInformation() == null)) {
 368             throw new RestProtocolException("bad-attribute", "Invalid preloadData received", HttpStatus.BAD_REQUEST.value());
 369         }
 370
 371         ConfigPreloadData preloadDataItem = preloadDataItems.get(0);
 372
 373         if (preloadDataItem.getPreloadData() != null) {
 374             dataExists = true;
 375         }
 376
 377         try {
 378             preloadDataItem.setPreloadData(objectMapper.writeValueAsString(preloadData));
 379             configPreloadDataRepository.save(preloadDataItem);
 380         } catch (JsonProcessingException e) {
 381             log.error("Cannot convert preload data", e);
 382             throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 383         }
 384
 385         if (dataExists) {
 386             return new ResponseEntity<>(HttpStatus.NO_CONTENT);
 387         } else {
 388             return new ResponseEntity<>(HttpStatus.CREATED);
 389         }
 390     }
 391
 392     @Override
 393     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesDelete() {
 394         configServicesRepository.deleteAll();
 395         return new ResponseEntity<>(HttpStatus.NO_CONTENT);
 396     }
 397
 398     @Override
 399     public ResponseEntity<GenericResourceApiServiceModelInfrastructure> configGENERICRESOURCEAPIservicesGet() throws RestApplicationException {
 400         GenericResourceApiServiceModelInfrastructure modelInfrastructure = new GenericResourceApiServiceModelInfrastructure();
 401
 402         if (configServicesRepository.count() == 0)  {
 403             throw new RestApplicationException("data-missing", "Request could not be completed because the relevant data model content does not exist", HttpStatus.NOT_FOUND.value());
 404         }
 405
 406         for (ConfigServices service : configServicesRepository.findAll()) {
 407             GenericResourceApiServicemodelinfrastructureService serviceItem = new GenericResourceApiServicemodelinfrastructureService();
 408             serviceItem.setServiceInstanceId(service.getSvcInstanceId());
 409             if (service.getSvcData() != null) {
 410             try {
 411                 serviceItem.setServiceData(objectMapper.readValue(service.getSvcData(), GenericResourceApiServicedataServiceData.class));
 412             } catch (JsonProcessingException e) {
 413                 log.error("Could not deserialize service data for {}", service.getSvcInstanceId(), e);
 414                 throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 415
 416             }
 417         }
 418             serviceItem.setServiceStatus(service.getServiceStatus());
 419             modelInfrastructure.addServiceItem(serviceItem);
 420         }
 421
 422
 423         return new ResponseEntity<>(modelInfrastructure, HttpStatus.OK);
 424
 425     }
 426
 427     @Override
 428     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesPost(@Valid GenericResourceApiServiceModelInfrastructure modelInfrastructure) throws RestApplicationException, RestProtocolException {
 429         List<ConfigServices> newServices = new LinkedList<>();
 430
 431         for (GenericResourceApiServicemodelinfrastructureService serviceItem : modelInfrastructure.getService()) {
 432             String svcInstanceId = serviceItem.getServiceInstanceId();
 433             List<ConfigServices> existingService = configServicesRepository.findBySvcInstanceId(svcInstanceId);
 434             if ((existingService != null) && !existingService.isEmpty()) {
 435                 log.error("Service data already exists for {}", svcInstanceId);
 436                 throw new RestProtocolException("data-exists", "Data already exists for service-instance-id " + svcInstanceId, HttpStatus.CONFLICT.value());
 437             }
 438             ConfigServices service = new ConfigServices();
 439             service.setSvcInstanceId(svcInstanceId);
 440             try {
 441                 service.setSvcData(objectMapper.writeValueAsString(serviceItem.getServiceData()));
 442             } catch (JsonProcessingException e) {
 443                 log.error("Could not serialize service data for {}", service.getSvcInstanceId(), e);
 444                 throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 445
 446             }
 447             service.setServiceStatus(serviceItem.getServiceStatus());
 448             newServices.add(service);
 449         }
 450
 451         for (ConfigServices service : newServices) {
 452             configServicesRepository.save(service);
 453         }
 454
 455         return new ResponseEntity<>(HttpStatus.CREATED);
 456
 457     }
 458
 459     @Override
 460     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesPut(@Valid GenericResourceApiServiceModelInfrastructure modelInfrastructure) throws RestApplicationException {
 461
 462         List<ConfigServices> newServices = new LinkedList<>();
 463         boolean dataExists = false;
 464
 465         for (GenericResourceApiServicemodelinfrastructureService serviceItem : modelInfrastructure.getService()) {
 466             String svcInstanceId = serviceItem.getServiceInstanceId();
 467             List<ConfigServices> existingService = configServicesRepository.findBySvcInstanceId(svcInstanceId);
 468             if ((existingService != null) && !existingService.isEmpty()) {
 469                 dataExists = true;
 470             }
 471             ConfigServices service = new ConfigServices();
 472             service.setSvcInstanceId(svcInstanceId);
 473             try {
 474                 service.setSvcData(objectMapper.writeValueAsString(serviceItem.getServiceData()));
 475             } catch (JsonProcessingException e) {
 476                 log.error("Could not serialize service data for {}", service.getSvcInstanceId(), e);
 477                 throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 478
 479             }
 480             service.setServiceStatus(serviceItem.getServiceStatus());
 481             newServices.add(service);
 482         }
 483
 484         for (ConfigServices service : newServices) {
 485             configServicesRepository.save(service);
 486         }
 487
 488         if (dataExists) {
 489             return new ResponseEntity<>(HttpStatus.NO_CONTENT);
 490         } else {
 491             return new ResponseEntity<>(HttpStatus.CREATED);
 492         }
 493
 494     }
 495
 496     @Override
 497     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesServicePost(@Valid GenericResourceApiServicemodelinfrastructureService servicesData) throws RestApplicationException {
 498         String svcInstanceId = servicesData.getServiceInstanceId();
 499         try {
 500             String svcData = objectMapper.writeValueAsString(servicesData.getServiceData());
 501             ConfigServices configService = new ConfigServices(svcInstanceId, svcData, servicesData.getServiceStatus());
 502             configServicesRepository.deleteBySvcInstanceId(svcInstanceId);
 503             configServicesRepository.save(configService);
 504         } catch (JsonProcessingException e) {
 505             log.error("Cannot convert service data", e);
 506             throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 507
 508         }
 509         return new ResponseEntity<>(HttpStatus.OK);
 510     }
 511
 512     @Override
 513     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdDelete(String serviceInstanceId) {
 514         configServicesRepository.deleteBySvcInstanceId(serviceInstanceId);
 515         return new ResponseEntity<>(HttpStatus.NO_CONTENT);
 516     }
 517
 518     @Override
 519     public ResponseEntity<GenericResourceApiServicemodelinfrastructureService> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdGet(String serviceInstanceId) throws RestApplicationException {
 520         GenericResourceApiServicemodelinfrastructureService retval = null;
 521
 522         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
 523
 524         if (services.isEmpty()) {
 525             return new ResponseEntity<>(HttpStatus.NOT_FOUND);
 526         } else {
 527             ConfigServices service = services.get(0);
 528             retval = new GenericResourceApiServicemodelinfrastructureService();
 529             retval.setServiceInstanceId(serviceInstanceId);
 530             retval.setServiceStatus(service.getServiceStatus());
 531             try {
 532                 retval.setServiceData(objectMapper.readValue(service.getSvcData(), GenericResourceApiServicedataServiceData.class));
 533             } catch (JsonProcessingException e) {
 534                 log.error("Could not deserialize service data for service instance id {}", serviceInstanceId, e);
 535                 throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 536
 537             }
 538         }
 539
 540
 541         return new ResponseEntity<>(retval, HttpStatus.OK);
 542
 543     }
 544
 545     @Override
 546     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdPost(String svcInstanceId, @Valid GenericResourceApiServicemodelinfrastructureService newService) throws RestApplicationException, RestProtocolException {
 547
 548         List<ConfigServices> existingService = configServicesRepository.findBySvcInstanceId(svcInstanceId);
 549         if ((existingService != null) && !existingService.isEmpty()) {
 550             log.error("Service data already exists for {}", svcInstanceId);
 551             throw new RestProtocolException("data-exists", "Data already exists for service-instance-id " + svcInstanceId, HttpStatus.CONFLICT.value());
 552         }
 553         ConfigServices service = new ConfigServices();
 554         service.setSvcInstanceId(svcInstanceId);
 555         try {
 556             service.setSvcData(objectMapper.writeValueAsString(newService.getServiceData()));
 557         } catch (JsonProcessingException e) {
 558             log.error("Could not serialize service data for {}", service.getSvcInstanceId(), e);
 559             throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 560
 561         }
 562         service.setServiceStatus(newService.getServiceStatus());
 563         configServicesRepository.save(service);
 564
 565         return new ResponseEntity<>(HttpStatus.CREATED);
 566     }
 567
 568     @Override
 569     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdPut(String serviceInstanceId, @Valid GenericResourceApiServicemodelinfrastructureService newService) throws RestApplicationException {
 570
 571         boolean dataExists = false;
 572
 573         String svcInstanceId = newService.getServiceInstanceId();
 574
 575         ConfigServices service = null;
 576         List<ConfigServices> existingService = configServicesRepository.findBySvcInstanceId(svcInstanceId);
 577         if ((existingService != null) && !existingService.isEmpty()) {
 578             dataExists = true;
 579             service = existingService.get(0);
 580         } else {
 581             service = new ConfigServices();
 582             service.setSvcInstanceId(svcInstanceId);
 583         }
 584
 585         try {
 586             service.setSvcData(objectMapper.writeValueAsString(newService.getServiceData()));
 587         } catch (JsonProcessingException e) {
 588             log.error("Could not serialize service data for {}", service.getSvcInstanceId(), e);
 589             throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 590
 591         }
 592         service.setServiceStatus(newService.getServiceStatus());
 593         configServicesRepository.save(service);
 594
 595         if (dataExists) {
 596             return new ResponseEntity<>(HttpStatus.NO_CONTENT);
 597         } else {
 598             return new ResponseEntity<>(HttpStatus.CREATED);
 599         }
 600     }
 601
 602
 603     @Override
 604     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceDataDelete(String serviceInstanceId) throws RestProtocolException {
 605         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
 606
 607         if ((services == null) || (services.isEmpty())) {
 608             throw new RestProtocolException("data-missing", "No service entry found", HttpStatus.NOT_FOUND.value());
 609         }
 610
 611         ConfigServices service = services.get(0);
 612         if (service.getSvcData() == null) {
 613             throw new RestProtocolException("data-missing", "No service-data found", HttpStatus.NOT_FOUND.value());
 614         }
 615         service.setSvcData(null);
 616         configServicesRepository.save(service);
 617
 618         return new ResponseEntity<>(HttpStatus.NO_CONTENT);
 619     }
 620
 621     @Override
 622     public ResponseEntity<GenericResourceApiServicedataServiceData> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceDataGet(String serviceInstanceId) throws RestApplicationException, RestProtocolException {
 623         GenericResourceApiServicedataServiceData serviceData = null;
 624
 625         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
 626         if ((services == null) || (services.isEmpty())) {
 627             throw new RestProtocolException("data-missing", "No service entry found", HttpStatus.NOT_FOUND.value());
 628         }
 629
 630         try {
 631             serviceData = objectMapper.readValue(services.get(0).getSvcData(), GenericResourceApiServicedataServiceData.class);
 632             return new ResponseEntity<>(serviceData, HttpStatus.OK);
 633         } catch (JsonProcessingException e) {
 634             log.error("Could not parse service data", e);
 635             throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 636         }
 637
 638     }
 639
 640     @Override
 641     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceDataPost(String serviceInstanceId, @Valid GenericResourceApiServicedataServiceData serviceData) throws RestApplicationException, RestProtocolException {
 642         ConfigServices service;
 643         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
 644         if ((services == null) || (services.isEmpty())) {
 645             throw new RestProtocolException("data-missing", "No service entry found", HttpStatus.NOT_FOUND.value());
 646         }
 647
 648         if ((serviceData == null) ||
 649                 (serviceData.getServiceInformation() == null)) {
 650             throw new RestProtocolException("bad-attribute", "Invalid service-data received", HttpStatus.BAD_REQUEST.value());
 651
 652         }
 653         service = services.get(0);
 654
 655         if ((service.getSvcData() != null) && (service.getSvcData().length() > 0)){
 656             log.error("service-data already exists for svcInstanceId {}", serviceInstanceId);
 657             throw new RestProtocolException("data-exists", "Data already exists for " + serviceInstanceId, HttpStatus.CONFLICT.value());
 658         }
 659
 660
 661         try {
 662             service.setSvcData(objectMapper.writeValueAsString(serviceData));
 663             configServicesRepository.save(service);
 664         } catch (JsonProcessingException e) {
 665             log.error("Could not serialize service data for svc instance id {}", serviceInstanceId, e);
 666             throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 667         }
 668
 669
 670         return new ResponseEntity<>(HttpStatus.CREATED);
 671
 672     }
 673
 674     @Override
 675     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceDataPut(String serviceInstanceId, @Valid GenericResourceApiServicedataServiceData serviceData) throws RestApplicationException, RestProtocolException {
 676         ConfigServices service;
 677         boolean dataExists = false;
 678
 679         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
 680         if ((services == null) || (services.isEmpty())) {
 681             throw new RestProtocolException("data-missing", "No service entry found", HttpStatus.NOT_FOUND.value());
 682         }
 683
 684         if ((serviceData == null) ||
 685                 (serviceData.getServiceInformation() == null)) {
 686             throw new RestProtocolException("bad-attribute", "Invalid service-data received", HttpStatus.BAD_REQUEST.value());
 687
 688         }
 689         service = services.get(0);
 690
 691         if ((service.getSvcData() != null) && (service.getSvcData().length() > 0)) {
 692             dataExists = true;
 693         }
 694
 695         try {
 696             service.setSvcData(objectMapper.writeValueAsString(serviceData));
 697             configServicesRepository.save(service);
 698         } catch (JsonProcessingException e) {
 699             log.error("Could not serialize service data for svc instance id {}", serviceInstanceId, e);
 700             throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
 701         }
 702
 703         if (dataExists) {
 704             return new ResponseEntity<>(HttpStatus.NO_CONTENT);
 705         } else {
 706             return new ResponseEntity<>(HttpStatus.CREATED);
 707         }
 708     }
 709
 710     @Override
 711     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceStatusDelete(String serviceInstanceId) throws RestProtocolException {
 712         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
 713
 714         if ((services == null) || (services.isEmpty())) {
 715             throw new RestProtocolException("data-missing", "No service entry found", HttpStatus.NOT_FOUND.value());
 716         }
 717
 718         ConfigServices service = services.get(0);
 719         if (service.getServiceStatus() == null) {
 720             throw new RestProtocolException("data-missing", "No service-status found", HttpStatus.NOT_FOUND.value());
 721         }
 722         service.setServiceStatus(null);
 723         configServicesRepository.save(service);
 724
 725         return new ResponseEntity<>(HttpStatus.NO_CONTENT);
 726
 727     }
 728
 729     @Override
 730     public ResponseEntity<GenericResourceApiServicestatusServiceStatus> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceStatusGet(String serviceInstanceId) throws RestApplicationException, RestProtocolException {
 731         GenericResourceApiServicestatusServiceStatus serviceStatus = null;
 732
 733         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
 734         if ((services == null) || (services.isEmpty())) {
 735             throw new RestProtocolException("data-missing", "No service entry found", HttpStatus.NOT_FOUND.value());
 736         }
 737
 738         serviceStatus = services.get(0).getServiceStatus();
 739         return new ResponseEntity<>(serviceStatus, HttpStatus.OK);
 740     }
 741
 742     @Override
 743     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceStatusPost(String serviceInstanceId, @Valid GenericResourceApiServicestatusServiceStatus serviceStatus) throws RestProtocolException {
 744         ConfigServices service;
 745         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
 746         if ((services == null) || (services.isEmpty())) {
 747             throw new RestProtocolException("data-missing", "No service entry found", HttpStatus.NOT_FOUND.value());
 748         }
 749
 750         if ((serviceStatus == null) ||
 751                 (serviceStatus.getAction() == null)) {
 752             throw new RestProtocolException("bad-attribute", "Invalid service-status received", HttpStatus.BAD_REQUEST.value());
 753
 754         }
 755         service = services.get(0);
 756
 757         if (service.getServiceStatus() != null) {
 758             log.error("service-status already exists for svcInstanceId {}", serviceInstanceId);
 759             throw new RestProtocolException("data-exists", "Data already exists for " + serviceInstanceId, HttpStatus.CONFLICT.value());
 760         }
 761
 762
 763         service.setServiceStatus(serviceStatus);
 764         configServicesRepository.save(service);
 765
 766
 767         return new ResponseEntity<>(HttpStatus.CREATED);
 768
 769     }
 770
 771     @Override
 772     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceStatusPut(String serviceInstanceId, @Valid GenericResourceApiServicestatusServiceStatus serviceStatus) throws RestProtocolException {
 773         ConfigServices service;
 774         boolean dataExists = false;
 775
 776         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
 777         if ((services == null) || (services.isEmpty())) {
 778             throw new RestProtocolException("data-missing", "No service entry found", HttpStatus.NOT_FOUND.value());
 779         }
 780
 781         if ((serviceStatus == null) ||
 782                 (serviceStatus.getAction() == null)) {
 783             throw new RestProtocolException("bad-attribute", "Invalid service-status received", HttpStatus.BAD_REQUEST.value());
 784
 785         }
 786         service = services.get(0);
 787
 788         if (service.getServiceStatus() != null) {
 789             dataExists = true;
 790         }
 791
 792
 793         service.setServiceStatus(serviceStatus);
 794         configServicesRepository.save(service);
 795
 796         if (dataExists) {
 797             return new ResponseEntity<>(HttpStatus.NO_CONTENT);
 798         } else {
 799             return new ResponseEntity<>(HttpStatus.CREATED);
 800         }
 801     }
 802
 803     /**
 804      * Deletes VNF data from the Config table specified Service Instance.
 805      * <p>
 806      * Maps to /config/GENERIC-RESOURCE-API:services/service/{service-instance-id}/service-data/vnfs/vnf/{vnf-id}/
 807      * @param serviceInstanceId the Service Instance ID to perform the delete on
 808      * @param vnfId the VNF ID of the VNF to delete
 809      * @return HttpStatus.NO_CONTENT (204) on successful delete
 810      *         <p>
 811      *         HttpStatus.BAD_REQUEST (400) if unmarshalling Service Data from
 812      *         the database fails, there is no VNF data for {@code vnfId}, or
 813      *         writing Service Data back to the database fails.
 814      *         <p>
 815      *         HttpStatus.NOT_FOUND (404) if {@code serviceInstanceId} does
 816      *         not exist.
 817      */
 818     @Override
 819     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceDataVnfsVnfVnfIdDelete(String serviceInstanceId, String vnfId) throws RestException {
 820         log.info("DELETE | VNF Data for ({})", vnfId);
 821
 822         /* The logic may need to be moved inside of this check or this check
 823          * may need to be removed.
 824          */
 825         if(getObjectMapper().isPresent() && getAcceptHeader().isPresent()) {
 826             log.info("Something with header.");
 827         } else {
 828             log.warn("ObjectMapper or HttpServletRequest not configured in default ConfigApi interface so no example is generated");
 829         }
 830
 831         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
 832         ConfigServices data;
 833         if((services == null) || (services.isEmpty())) {
 834             log.info("Could not find data for ({}).", serviceInstanceId);
 835             // Or throw the data not found error?
 836             throw new RestProtocolException("data-missing", "Service Instance ID not found.", HttpStatus.NOT_FOUND.value());
 837         } else {
 838             data = services.get(0);
 839         }
 840
 841         GenericResourceApiServicedataServiceData svcData;
 842         try {
 843             svcData = objectMapper.readValue(data.getSvcData(), GenericResourceApiServicedataServiceData.class);
 844         } catch(JsonProcessingException e) {
 845             // Or throw the data not found error?
 846             log.error("Could not map service data for ({})", serviceInstanceId);
 847             return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
 848         }
 849         if(svcData == null) {
 850             // Or throw the data not found error?
 851             log.info("Could not find Service Data for ({}).", serviceInstanceId);
 852             throw new RestProtocolException("data-missing", "Service data not found.", HttpStatus.NOT_FOUND.value());
 853         }
 854
 855         GenericResourceApiServicedataServicedataVnfs vnfs = svcData.getVnfs();
 856         if(vnfs == null) {
 857             // Or throw the data not found error?
 858             log.info("VNF List not found for ({}).", serviceInstanceId);
 859             throw new RestProtocolException("data-missing", "VNFs not found.", HttpStatus.NOT_FOUND.value());
 860         }
 861
 862         Stream<GenericResourceApiServicedataServicedataVnfsVnf> vnfStream = svcData.getVnfs().getVnf().stream();
 863         if(vnfStream.noneMatch(targetVnf -> targetVnf.getVnfId().equals(vnfId))) {
 864             // Data was not found
 865             log.error("Did not find VNF ({}) in data.", vnfId);
 866             throw new RestProtocolException("data-missing", "VNF ID not found.", HttpStatus.NOT_FOUND.value());
 867         }
 868         // Recreate the stream per Sonar?
 869         vnfStream = svcData.getVnfs().getVnf().stream();
 870         svcData.getVnfs().setVnf(vnfStream.filter(targetVnf -> !targetVnf.getVnfId().equals(vnfId)).collect(Collectors.toList()));
 871
 872         // Map and save the new data
 873         try {
 874             data.setSvcData(objectMapper.writeValueAsString(svcData));
 875             configServicesRepository.save(data);
 876             return new ResponseEntity<>(HttpStatus.NO_CONTENT);
 877         } catch(JsonProcessingException e) {
 878             log.error("Error mapping object to JSON", e);
 879             // Should probably be a 500 INTERNAL_SERVICE_ERROR
 880             throw new RestProtocolException("internal-service-error", "Failed to save data.", HttpStatus.BAD_REQUEST.value());
 881         }
 882     }
 883
 884     /**
 885      * Extracts VNF data from the Config table specified Service Instance.
 886      * <p>
 887      * Maps to /config/GENERIC-RESOURCE-API:services/service/{service-instance-id}/service-data/vnfs/vnf/{vnf-id}/
 888      * @param serviceInstanceId the Service Instance ID to lookup data for
 889      * @param vnfId the VNF ID of the VNF to return
 890      * @return HttpStatus.OK (200) if the data is found.
 891      * @throws RestException if the data does not exist.
 892      */
 893     @Override
 894     public ResponseEntity<GenericResourceApiServicedataServicedataVnfsVnf> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceDataVnfsVnfVnfIdGet(String serviceInstanceId, String vnfId) throws RestException {
 895         log.info("GET | VNF Data for ({})", vnfId);
 896         if(getObjectMapper().isPresent() && getAcceptHeader().isPresent()) {
 897             if(getAcceptHeader().get().contains("application/json")) {
 898             }
 899         } else {
 900             log.warn("ObjectMapper or HttpServletRequest not configured in default ConfigApi interface so no example is generated");
 901         }
 902         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
 903         if((services == null) || (services.isEmpty())) {
 904             throw new RestProtocolException("data-missing", "No service entry found", HttpStatus.NOT_FOUND.value());
 905         }
 906
 907         Optional<GenericResourceApiServicedataServicedataVnfsVnf> vnf = getVnfObject(services.get(0), vnfId);
 908         if(vnf.isPresent()) {
 909             return new ResponseEntity<>(vnf.get(), HttpStatus.OK);
 910         } else {
 911             log.info("No information found for {}", vnfId);
 912             throw new RestApplicationException("data-missing", "Request could not be completed because the relevant data model content does not exist", HttpStatus.NOT_FOUND.value());
 913         }
 914     }
 915
 916     /**
 917      * Creates or updates VNF data in the Config table for a specified Service
 918      * Instance. If it is a new Service Instance or a new VNF, creates all
 919      * necessary parent data containers, then performs the updates.
 920      * <p>
 921      * Maps to /config/GENERIC-RESOURCE-API:services/service/{service-instance-id}/service-data/vnfs/vnf/{vnf-id}/
 922      * @param serviceInstanceId the Service Instance ID to perform the delete on
 923      * @param vnfId the VNF ID of the VNF to delete
 924      * @param genericResourceApiServicedataServicedataVnfsVnfBodyParam the playload
 925      * @return HttpStatus.CREATED (201) on successful create
 926      *         <p>
 927      *         HttpStatus.NO_CONTENT (204) on successful update
 928      *         <p>
 929      *         HttpStatus.BAD_REQUEST (400) if {@code vnfId} does not match
 930      *         what is specified in the
 931      *         {@code genericResourceApiServicedataServicedataVnfsVnfBodyParam}
 932      *         , or if updating the database fails.
 933      * @throws RestException
 934      */
 935     @Override
 936     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceDataVnfsVnfVnfIdPut(String serviceInstanceId, String vnfId, GenericResourceApiServicedataServicedataVnfsVnf genericResourceApiServicedataServicedataVnfsVnfBodyParam) throws RestException {
 937         log.info("PUT | VNF Data for ({})", vnfId);
 938         if(!vnfId.equals(genericResourceApiServicedataServicedataVnfsVnfBodyParam.getVnfId())) {
 939             throw new RestProtocolException("bad-attribute", "vnf-id mismatch", HttpStatus.BAD_REQUEST.value());
 940         }
 941         if(getObjectMapper().isPresent() && getAcceptHeader().isPresent()) {
 942             log.info("Something with header");
 943         } else {
 944             log.warn("ObjectMapper or HttpServletRequest not configured in default ConfigApi interface so no example is generated");
 945         }
 946
 947         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
 948         ConfigServices data;
 949         if((services == null) || (services.isEmpty())) {
 950             log.info("Could not find data for ({}). Creating new Service Object.", serviceInstanceId);
 951             data = new ConfigServices();
 952             data.setSvcInstanceId(serviceInstanceId);
 953         } else {
 954             data = services.get(0);
 955         }
 956
 957         GenericResourceApiServicedataServiceData svcData = null;
 958         try {
 959             svcData = objectMapper.readValue(data.getSvcData(), GenericResourceApiServicedataServiceData.class);
 960         } catch(JsonProcessingException e) {
 961             log.error("Could not map service data for ({})", serviceInstanceId);
 962         }
 963         if(svcData == null) {
 964             log.info("Could not find Service Data for ({}). Creating new Service Data Container", serviceInstanceId);
 965             svcData = new GenericResourceApiServicedataServiceData();
 966         }
 967         if(svcData.getVnfs() == null) {
 968             log.info("VNF List not found for ({}). Creating new VNF List Container.", serviceInstanceId);
 969             svcData.setVnfs(new GenericResourceApiServicedataServicedataVnfs());
 970             svcData.getVnfs().setVnf(new ArrayList<>());
 971         }
 972
 973         GenericResourceApiServicedataServicedataVnfs vnflist = new GenericResourceApiServicedataServicedataVnfs();
 974         HttpStatus responseStatus = HttpStatus.NO_CONTENT;
 975         if(svcData.getVnfs().getVnf().isEmpty()) {
 976             log.info("Creating VNF data for ({})", vnfId);
 977             vnflist.addVnfItem(genericResourceApiServicedataServicedataVnfsVnfBodyParam);
 978             responseStatus = HttpStatus.CREATED;
 979         } else {
 980             log.info("Updating VNF data for ({})", vnfId);
 981             // Filter out all of the other vnf objects into a new VNF List
 982             // Replace if a delete method exists
 983             svcData.getVnfs()
 984                     .getVnf()
 985                     .stream()
 986                     .filter(targetVnf -> !targetVnf.getVnfId().equals(vnfId))
 987                     .forEach(vnflist::addVnfItem);
 988             vnflist.addVnfItem(genericResourceApiServicedataServicedataVnfsVnfBodyParam);
 989         }
 990         svcData.setVnfs(vnflist);
 991         // Map and save the new data
 992         try {
 993             data.setSvcData(objectMapper.writeValueAsString(svcData));
 994             configServicesRepository.save(data);
 995             return new ResponseEntity<>(responseStatus);
 996         } catch(JsonProcessingException e) {
 997             log.error("Error mapping object to JSON", e);
 998             // Should probably be a 500 INTERNAL_SERVICE_ERROR
 999             return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
1000         }
1001     }
1002
1003     /**
1004      * Extracts VNF Topology data from the Config table specified Service
1005      * Instance and VNF ID.
1006      * <p>
1007      * Maps to /config/GENERIC-RESOURCE-API:services/service/{service-instance-id}/service-data/vnfs/vnf/{vnf-id}/vnf-data/vnf-topology/
1008      * @param serviceInstanceId the Service Instance ID to lookup data for
1009      * @param vnfId the VNF ID of the VNF to extract topology data from.
1010      * @return HttpStatus.OK (200) if the data is found.
1011      * @throws RestException if the data does not exist.
1012      */
1013     @Override
1014     public ResponseEntity<GenericResourceApiVnftopologyVnfTopology> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceDataVnfsVnfVnfIdVnfDataVnfTopologyGet(String serviceInstanceId, String vnfId) throws RestException {
1015         log.info("GET | VNF Topology for ({})", vnfId);
1016         if(getObjectMapper().isPresent() && getAcceptHeader().isPresent()) {
1017             if (getAcceptHeader().get().contains("application/json")) {
1018
1019             }
1020         } else {
1021             log.warn("ObjectMapper or HttpServletRequest not configured in default ConfigApi interface so no example is generated");
1022         }
1023         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
1024         if((services == null) || (services.isEmpty())) {
1025             throw new RestProtocolException("data-missing", "No service entry found", HttpStatus.NOT_FOUND.value());
1026         }
1027
1028         Optional<GenericResourceApiServicedataServicedataVnfsVnf> vnf = getVnfObject(services.get(0), vnfId);
1029         // Drill down to find the data
1030         if(vnf.isPresent()
1031                    && vnf.get().getVnfData() != null
1032                    && vnf.get().getVnfData().getVnfTopology() != null) {
1033             return new ResponseEntity<>(vnf.get().getVnfData().getVnfTopology(), HttpStatus.OK);
1034         } else {
1035             log.info("No information found for {}", vnfId);
1036             throw new RestApplicationException("data-missing", "Request could not be completed because the relevant data model content does not exist", HttpStatus.NOT_FOUND.value());
1037         }
1038     }
1039
1040     /**
1041      * Creates or updates VNF Level Operation Status data in the Config table
1042      * for a specified Service Instance. If it is a new Service Instance or a
1043      * new VNF, creates all necessary parent data containers, then performs the
1044      * updates.
1045      * <p>
1046      * Maps to /config/GENERIC-RESOURCE-API:services/service/{service-instance-id}/service-data/vnfs/vnf/{vnf-id}/vnf-data/vnf-level-oper-status/
1047      * @param serviceInstanceId the Service Instance ID to perform the delete on
1048      * @param vnfId the VNF ID of the VNF to delete
1049      * @param genericResourceApiOperStatusDataBodyParam the payload
1050      * @return HttpStatus.CREATED (201) on successful create.
1051      *         <p>
1052      *         HttpStatus.NO_CONTENT (204) on successful update.
1053      *         <p>
1054      *         HttpStatus.BAD_REQUEST (400) if updating the database fails.
1055      * @throws RestException
1056      */
1057     @Override
1058     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceDataVnfsVnfVnfIdVnfDataVnfLevelOperStatusPut(String serviceInstanceId, String vnfId, GenericResourceApiOperStatusData genericResourceApiOperStatusDataBodyParam) throws RestException {
1059         log.info("PUT | VNF Level Oper Status ({})", vnfId);
1060         if(getObjectMapper().isPresent() && getAcceptHeader().isPresent()) {
1061         } else {
1062             log.warn("ObjectMapper or HttpServletRequest not configured in default ConfigApi interface so no example is generated");
1063         }
1064
1065         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
1066         ConfigServices data;
1067         if((services == null) || (services.isEmpty())) {
1068             log.info("Could not find data for ({}). Creating new Service Object.", serviceInstanceId);
1069             data = new ConfigServices();
1070             data.setSvcInstanceId(serviceInstanceId);
1071         } else {
1072             data = services.get(0);
1073         }
1074
1075         GenericResourceApiServicedataServiceData svcData = null;
1076         try {
1077             svcData = objectMapper.readValue(data.getSvcData(), GenericResourceApiServicedataServiceData.class);
1078         } catch(JsonProcessingException e) {
1079             log.error("Could not map service data for ({})", serviceInstanceId);
1080         }
1081         if(svcData == null) {
1082             log.info("Could not find Service Data for ({}). Creating new Service Data Container", serviceInstanceId);
1083             svcData = new GenericResourceApiServicedataServiceData();
1084         }
1085         if(svcData.getVnfs() == null) {
1086             log.info("VNF List not found for ({}). Creating new VNF List Container.", serviceInstanceId);
1087             svcData.setVnfs(new GenericResourceApiServicedataServicedataVnfs());
1088             svcData.getVnfs().setVnf(new ArrayList<>());
1089         }
1090
1091         GenericResourceApiServicedataServicedataVnfs vnflist = new GenericResourceApiServicedataServicedataVnfs();
1092         HttpStatus responseStatus = HttpStatus.NO_CONTENT;
1093         if(svcData.getVnfs().getVnf().isEmpty()) {
1094             log.info("Creating VNF data for ({})", vnfId);
1095             GenericResourceApiServicedataServicedataVnfsVnf vnf = new GenericResourceApiServicedataServicedataVnfsVnf();
1096             vnf.setVnfId(vnfId);
1097             vnf.setVnfData(new GenericResourceApiServicedataServicedataVnfsVnfVnfData());
1098             vnf.getVnfData().setVnfLevelOperStatus(genericResourceApiOperStatusDataBodyParam);
1099             vnflist.addVnfItem(vnf);
1100             responseStatus = HttpStatus.CREATED;
1101         } else {
1102             log.info("Updating VNF data for ({})", vnfId);
1103             // Filter out all of the other vnf objects into a new VNF List
1104             // Replace if a delete method exists
1105             svcData.getVnfs()
1106                     .getVnf()
1107                     .stream()
1108                     .filter(targetVnf -> !targetVnf.getVnfId().equals(vnfId))
1109                     .forEach(vnflist::addVnfItem);
1110             GenericResourceApiServicedataServicedataVnfsVnf vnf = new GenericResourceApiServicedataServicedataVnfsVnf();
1111             // If the vnf exists, set it up with new data
1112             Optional<GenericResourceApiServicedataServicedataVnfsVnf> vnfOptional = getVnfObject(data, vnfId);
1113             if(vnfOptional.isPresent()) {
1114                 vnf = vnfOptional.get();
1115             }
1116             if(vnf.getVnfData() == null) {
1117                 vnf.setVnfData(new GenericResourceApiServicedataServicedataVnfsVnfVnfData());
1118                 responseStatus = HttpStatus.CREATED;
1119             }
1120
1121             vnf.getVnfData().setVnfLevelOperStatus(genericResourceApiOperStatusDataBodyParam);
1122             vnflist.addVnfItem(vnf);
1123         }
1124
1125         svcData.setVnfs(vnflist);
1126         // Map and save the new data
1127         try {
1128             data.setSvcData(objectMapper.writeValueAsString(svcData));
1129             configServicesRepository.save(data);
1130             return new ResponseEntity<>(responseStatus);
1131         } catch(JsonProcessingException e) {
1132             log.error("Error mapping object to JSON", e);
1133             // Should probably be a 500 INTERNAL_SERVICE_ERROR
1134             return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
1135         }
1136     }
1137
1138     /**
1139      * Creates or updates VNF Onap Model Information data in the Config table
1140      * for a specified Service Instance. If it is a new Service Instance or a
1141      * new VNF, creates all necessary parent data containers, then performs the
1142      * updates.
1143      * <p>
1144      * Maps to /config/GENERIC-RESOURCE-API:services/service/{service-instance-id}/service-data/vnfs/vnf/{vnf-id}/vnf-data/vnf-topology/onap-model-information/
1145      * @param serviceInstanceId the Service Instance ID to perform the delete on
1146      * @param vnfId the VNF ID of the VNF to delete
1147      * @param genericResourceApiOnapmodelinformationOnapModelInformationBodyParam the payload
1148      * @return HttpStatus.CREATED (201) on successful create.
1149      *         <p>
1150      *         HttpStatus.NO_CONTENT (204) on successful update.
1151      *         <p>
1152      *         HttpStatus.BAD_REQUEST (400) if updating the database fails.
1153      * @throws RestException
1154      */
1155     @Override
1156     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceDataVnfsVnfVnfIdVnfDataVnfTopologyOnapModelInformationPut(String serviceInstanceId, String vnfId, GenericResourceApiOnapmodelinformationOnapModelInformation genericResourceApiOnapmodelinformationOnapModelInformationBodyParam) throws RestException {
1157         log.info("PUT | VNF Topology Onap Model Information ({})", vnfId);
1158         if(getObjectMapper().isPresent() && getAcceptHeader().isPresent()) {
1159         } else {
1160             log.warn("ObjectMapper or HttpServletRequest not configured in default ConfigApi interface so no example is generated");
1161         }
1162
1163         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
1164         ConfigServices data;
1165         if((services == null) || (services.isEmpty())) {
1166             log.info("Could not find data for ({}). Creating new Service Object.", serviceInstanceId);
1167             data = new ConfigServices();
1168             data.setSvcInstanceId(serviceInstanceId);
1169         } else {
1170             data = services.get(0);
1171         }
1172
1173         GenericResourceApiServicedataServiceData svcData = null;
1174         try {
1175             svcData = objectMapper.readValue(data.getSvcData(), GenericResourceApiServicedataServiceData.class);
1176         } catch(JsonProcessingException e) {
1177             log.error("Could not map service data for ({})", serviceInstanceId);
1178         }
1179         if(svcData == null) {
1180             log.info("Could not find Service Data for ({}). Creating new Service Data Container", serviceInstanceId);
1181             svcData = new GenericResourceApiServicedataServiceData();
1182         }
1183         if(svcData.getVnfs() == null) {
1184             log.info("VNF List not found for ({}). Creating new VNF List Container.", serviceInstanceId);
1185             svcData.setVnfs(new GenericResourceApiServicedataServicedataVnfs());
1186             svcData.getVnfs().setVnf(new ArrayList<>());
1187         }
1188
1189         GenericResourceApiServicedataServicedataVnfs vnflist = new GenericResourceApiServicedataServicedataVnfs();
1190         HttpStatus responseStatus = HttpStatus.NO_CONTENT;
1191         if(svcData.getVnfs().getVnf().isEmpty()) {
1192             log.info("Creating VNF data for ({})", vnfId);
1193             GenericResourceApiServicedataServicedataVnfsVnf vnf = new GenericResourceApiServicedataServicedataVnfsVnf();
1194             vnf.setVnfId(vnfId);
1195             vnf.setVnfData(new GenericResourceApiServicedataServicedataVnfsVnfVnfData());
1196             vnf.getVnfData().setVnfTopology(new GenericResourceApiVnftopologyVnfTopology());
1197             vnf.getVnfData().getVnfTopology().setOnapModelInformation(genericResourceApiOnapmodelinformationOnapModelInformationBodyParam);
1198             vnflist.addVnfItem(vnf);
1199             responseStatus = HttpStatus.CREATED;
1200         } else {
1201             log.info("Updating VNF data for ({})", vnfId);
1202             // Filter out all of the other vnf objects into a new VNF List
1203             // Replace if a delete method exists
1204             svcData.getVnfs()
1205                     .getVnf()
1206                     .stream()
1207                     .filter(targetVnf -> !targetVnf.getVnfId().equals(vnfId))
1208                     .forEach(vnflist::addVnfItem);
1209             GenericResourceApiServicedataServicedataVnfsVnf vnf = new GenericResourceApiServicedataServicedataVnfsVnf();
1210             // If the vnf exists, set it up with new data
1211             Optional<GenericResourceApiServicedataServicedataVnfsVnf> vnfOptional = getVnfObject(data, vnfId);
1212             if(vnfOptional.isPresent()) {
1213                 vnf = vnfOptional.get();
1214             }
1215             if(vnf.getVnfData() == null) {
1216                 vnf.setVnfData(new GenericResourceApiServicedataServicedataVnfsVnfVnfData());
1217             }
1218             if(vnf.getVnfData().getVnfTopology() == null) {
1219                 vnf.getVnfData().setVnfTopology(new GenericResourceApiVnftopologyVnfTopology());
1220                 responseStatus = HttpStatus.CREATED;
1221             }
1222
1223             vnf.getVnfData().getVnfTopology().setOnapModelInformation(genericResourceApiOnapmodelinformationOnapModelInformationBodyParam);
1224             vnflist.addVnfItem(vnf);
1225         }
1226
1227         svcData.setVnfs(vnflist);
1228         // Map and save the new data
1229         try {
1230             data.setSvcData(objectMapper.writeValueAsString(svcData));
1231             configServicesRepository.save(data);
1232             return new ResponseEntity<>(responseStatus);
1233         } catch(JsonProcessingException e) {
1234             log.error("Error mapping object to JSON", e);
1235             // Should probably be a 500 INTERNAL_SERVICE_ERROR
1236             return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
1237         }
1238     }
1239
1240     /**
1241      * Creates or updates VNF Network data in the Config table for a specified
1242      * Service Instance. If it is a new Service Instance or a new VNF, creates
1243      * all necessary parent data containers, then performs the updates.
1244      * <p>
1245      * Maps to /config/GENERIC-RESOURCE-API:services/service/{service-instance-id}/service-data/vnfs/vnf/{vnf-id}/vnf-data/vnf-topology/vnf-resource-assignments/vnf-networks/
1246      * @param serviceInstanceId the Service Instance ID to perform the delete on
1247      * @param vnfId the VNF ID of the VNF to delete
1248      * @param genericResourceApiVnfresourceassignmentsVnfresourceassignmentsVnfNetworksBodyParam the payload
1249      * @return HttpStatus.CREATED (201) on successful create.
1250      *         <p>
1251      *         HttpStatus.NO_CONTENT (204) on successful update.
1252      *         <p>
1253      *         HttpStatus.BAD_REQUEST (400) if updating the database fails.
1254      * @throws RestException
1255      */
1256     @Override
1257     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceDataVnfsVnfVnfIdVnfDataVnfTopologyVnfResourceAssignmentsVnfNetworksPut(String serviceInstanceId, String vnfId, GenericResourceApiVnfresourceassignmentsVnfresourceassignmentsVnfNetworks genericResourceApiVnfresourceassignmentsVnfresourceassignmentsVnfNetworksBodyParam) throws RestException {
1258         log.info("PUT | VNF Topology VNF Resource Assignments VNF Networks ({})", vnfId);
1259         if(getObjectMapper().isPresent() && getAcceptHeader().isPresent()) {
1260         } else {
1261             log.warn("ObjectMapper or HttpServletRequest not configured in default ConfigApi interface so no example is generated");
1262         }
1263
1264         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
1265         ConfigServices data;
1266         if((services == null) || (services.isEmpty())) {
1267             log.info("Could not find data for ({}). Creating new Service Object.", serviceInstanceId);
1268             data = new ConfigServices();
1269             data.setSvcInstanceId(serviceInstanceId);
1270         } else {
1271             data = services.get(0);
1272         }
1273
1274         GenericResourceApiServicedataServiceData svcData = null;
1275         try {
1276             svcData = objectMapper.readValue(data.getSvcData(), GenericResourceApiServicedataServiceData.class);
1277         } catch(JsonProcessingException e) {
1278             log.error("Could not map service data for ({})", serviceInstanceId);
1279         }
1280         if(svcData == null) {
1281             log.info("Could not find Service Data for ({}). Creating new Service Data Container", serviceInstanceId);
1282             svcData = new GenericResourceApiServicedataServiceData();
1283         }
1284         if(svcData.getVnfs() == null) {
1285             log.info("VNF List not found for ({}). Creating new VNF List Container.", serviceInstanceId);
1286             svcData.setVnfs(new GenericResourceApiServicedataServicedataVnfs());
1287             svcData.getVnfs().setVnf(new ArrayList<>());
1288         }
1289
1290         GenericResourceApiServicedataServicedataVnfs vnflist = new GenericResourceApiServicedataServicedataVnfs();
1291         HttpStatus responseStatus = HttpStatus.NO_CONTENT;
1292         if(svcData.getVnfs().getVnf().isEmpty()) {
1293             log.info("Creating VNF data for ({})", vnfId);
1294             GenericResourceApiServicedataServicedataVnfsVnf vnf = new GenericResourceApiServicedataServicedataVnfsVnf();
1295             vnf.setVnfId(vnfId);
1296             vnf.setVnfData(new GenericResourceApiServicedataServicedataVnfsVnfVnfData());
1297             vnf.getVnfData().setVnfTopology(new GenericResourceApiVnftopologyVnfTopology());
1298             vnf.getVnfData().getVnfTopology().setVnfResourceAssignments(new GenericResourceApiVnfresourceassignmentsVnfResourceAssignments());
1299             vnf.getVnfData().getVnfTopology().getVnfResourceAssignments().setVnfNetworks(genericResourceApiVnfresourceassignmentsVnfresourceassignmentsVnfNetworksBodyParam);
1300             vnflist.addVnfItem(vnf);
1301             responseStatus = HttpStatus.CREATED;
1302         } else {
1303             log.info("Updating VNF data for ({})", vnfId);
1304             // Filter out all of the other vnf objects into a new VNF List
1305             // Replace if a delete method exists
1306             svcData.getVnfs()
1307                     .getVnf()
1308                     .stream()
1309                     .filter(targetVnf -> !targetVnf.getVnfId().equals(vnfId))
1310                     .forEach(vnflist::addVnfItem);
1311             GenericResourceApiServicedataServicedataVnfsVnf vnf = new GenericResourceApiServicedataServicedataVnfsVnf();
1312             // If the vnf exists, set it up with new data
1313             Optional<GenericResourceApiServicedataServicedataVnfsVnf> vnfOptional = getVnfObject(data, vnfId);
1314             if(vnfOptional.isPresent()) {
1315                 vnf = vnfOptional.get();
1316             }
1317             if(vnf.getVnfData() == null) {
1318                 vnf.setVnfData(new GenericResourceApiServicedataServicedataVnfsVnfVnfData());
1319             }
1320             if(vnf.getVnfData().getVnfTopology() == null) {
1321                 vnf.getVnfData().setVnfTopology(new GenericResourceApiVnftopologyVnfTopology());
1322             }
1323             if(vnf.getVnfData().getVnfTopology().getVnfResourceAssignments() == null) {
1324                 vnf.getVnfData().getVnfTopology().setVnfResourceAssignments(new GenericResourceApiVnfresourceassignmentsVnfResourceAssignments());
1325                 responseStatus = HttpStatus.CREATED;
1326             }
1327
1328             vnf.getVnfData().getVnfTopology().getVnfResourceAssignments().setVnfNetworks(genericResourceApiVnfresourceassignmentsVnfresourceassignmentsVnfNetworksBodyParam);
1329             vnflist.addVnfItem(vnf);
1330         }
1331
1332         svcData.setVnfs(vnflist);
1333         // Map and save the new data
1334         try {
1335             data.setSvcData(objectMapper.writeValueAsString(svcData));
1336             configServicesRepository.save(data);
1337             return new ResponseEntity<>(responseStatus);
1338         } catch(JsonProcessingException e) {
1339             log.error("Error mapping object to JSON", e);
1340             // Should probably be a 500 INTERNAL_SERVICE_ERROR
1341             return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
1342         }
1343     }
1344
1345     /**
1346      * Creates or updates VNF Network Role data in the Config table for a
1347      * specified Service Instance. If it is a new Service Instance or a new
1348      * VNF, creates all necessary parent data containers, then performs the
1349      * updates.
1350      * <p>
1351      * Maps to /config/GENERIC-RESOURCE-API:services/service/{service-instance-id}/service-data/vnfs/vnf/{vnf-id}/vnf-data/vnf-topology/vnf-resource-assignments/vnf-networks/vnf-network/{network-role}/
1352      * @param serviceInstanceId the Service Instance ID to perform the delete on
1353      * @param vnfId the VNF ID of the VNF to delete
1354      * @param genericResourceApiVnfNetworkDataBodyParam the payload
1355      * @return HttpStatus.CREATED (201) on successful create.
1356      *         <p>
1357      *         HttpStatus.NO_CONTENT (204) on successful update.
1358      *         <p>
1359      *         HttpStatus.BAD_REQUEST (400) if updating the database fails.
1360      * @throws RestException
1361      */
1362     @Override
1363     public ResponseEntity<Void> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceDataVnfsVnfVnfIdVnfDataVnfTopologyVnfResourceAssignmentsVnfNetworksVnfNetworkNetworkRolePut(String serviceInstanceId, String vnfId, String networkRole, GenericResourceApiVnfNetworkData genericResourceApiVnfNetworkDataBodyParam) throws RestException {
1364         log.info("PUT | VNF Network Network Role ({})", vnfId);
1365         if(!networkRole.equals(genericResourceApiVnfNetworkDataBodyParam.getNetworkRole())) {
1366             throw new RestProtocolException("bad-attribute", "network-role mismatch", HttpStatus.BAD_REQUEST.value());
1367         }
1368         if(getObjectMapper().isPresent() && getAcceptHeader().isPresent()) {
1369         } else {
1370             log.warn("ObjectMapper or HttpServletRequest not configured in default ConfigApi interface so no example is generated");
1371         }
1372
1373         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
1374         ConfigServices data;
1375         if((services == null) || (services.isEmpty())) {
1376             log.info("Could not find data for ({}). Creating new Service Object.", serviceInstanceId);
1377             data = new ConfigServices();
1378             data.setSvcInstanceId(serviceInstanceId);
1379         } else {
1380             data = services.get(0);
1381         }
1382
1383         GenericResourceApiServicedataServiceData svcData = null;
1384         try {
1385             svcData = objectMapper.readValue(data.getSvcData(), GenericResourceApiServicedataServiceData.class);
1386         } catch(JsonProcessingException e) {
1387             log.error("Could not map service data for ({})", serviceInstanceId);
1388         }
1389         if(svcData == null) {
1390             log.info("Could not find Service Data for ({}). Creating new Service Data Container", serviceInstanceId);
1391             svcData = new GenericResourceApiServicedataServiceData();
1392         }
1393         if(svcData.getVnfs() == null) {
1394             log.info("VNF List not found for ({}). Creating new VNF List Container.", serviceInstanceId);
1395             svcData.setVnfs(new GenericResourceApiServicedataServicedataVnfs());
1396             svcData.getVnfs().setVnf(new ArrayList<>());
1397         }
1398
1399         GenericResourceApiServicedataServicedataVnfs vnflist = new GenericResourceApiServicedataServicedataVnfs();
1400         HttpStatus responseStatus = HttpStatus.NO_CONTENT;
1401         if(svcData.getVnfs().getVnf().isEmpty()) {
1402             log.info("Creating VNF data for ({})", vnfId);
1403             GenericResourceApiServicedataServicedataVnfsVnf vnf = new GenericResourceApiServicedataServicedataVnfsVnf();
1404             vnf.setVnfId(vnfId);
1405             vnf.setVnfData(new GenericResourceApiServicedataServicedataVnfsVnfVnfData());
1406             vnf.getVnfData().setVnfTopology(new GenericResourceApiVnftopologyVnfTopology());
1407             vnf.getVnfData().getVnfTopology().setVnfResourceAssignments(new GenericResourceApiVnfresourceassignmentsVnfResourceAssignments());
1408             vnf.getVnfData().getVnfTopology().getVnfResourceAssignments().setVnfNetworks(new GenericResourceApiVnfresourceassignmentsVnfresourceassignmentsVnfNetworks());
1409             vnf.getVnfData().getVnfTopology().getVnfResourceAssignments().getVnfNetworks().setVnfNetwork(new ArrayList<>());
1410             vnf.getVnfData().getVnfTopology().getVnfResourceAssignments().getVnfNetworks().addVnfNetworkItem(genericResourceApiVnfNetworkDataBodyParam);
1411             vnflist.addVnfItem(vnf);
1412             responseStatus = HttpStatus.CREATED;
1413         } else {
1414             log.info("Updating VNF data for ({})", vnfId);
1415             // Filter out all of the other vnf objects into a new VNF List
1416             // Replace if a delete method exists
1417             svcData.getVnfs()
1418                     .getVnf()
1419                     .stream()
1420                     .filter(targetVnf -> !targetVnf.getVnfId().equals(vnfId))
1421                     .forEach(vnflist::addVnfItem);
1422             GenericResourceApiServicedataServicedataVnfsVnf vnf = new GenericResourceApiServicedataServicedataVnfsVnf();
1423             // If the vnf exists, set it up with new data
1424             Optional<GenericResourceApiServicedataServicedataVnfsVnf> vnfOptional = getVnfObject(data, vnfId);
1425             if(vnfOptional.isPresent()) {
1426                 vnf = vnfOptional.get();
1427             }
1428             if(vnf.getVnfData() == null) {
1429                 vnf.setVnfData(new GenericResourceApiServicedataServicedataVnfsVnfVnfData());
1430             }
1431             if(vnf.getVnfData().getVnfTopology() == null) {
1432                 vnf.getVnfData().setVnfTopology(new GenericResourceApiVnftopologyVnfTopology());
1433             }
1434             if(vnf.getVnfData().getVnfTopology().getVnfResourceAssignments() == null) {
1435                 vnf.getVnfData().getVnfTopology().setVnfResourceAssignments(new GenericResourceApiVnfresourceassignmentsVnfResourceAssignments());
1436             }
1437             if(vnf.getVnfData().getVnfTopology().getVnfResourceAssignments().getVnfNetworks() == null) {
1438                 log.info("Creating new VnfNetworks");
1439                 vnf.getVnfData().getVnfTopology().getVnfResourceAssignments().setVnfNetworks(new GenericResourceApiVnfresourceassignmentsVnfresourceassignmentsVnfNetworks());
1440             }
1441
1442             GenericResourceApiVnfresourceassignmentsVnfresourceassignmentsVnfNetworks networkList = new GenericResourceApiVnfresourceassignmentsVnfresourceassignmentsVnfNetworks();
1443             if(vnf.getVnfData().getVnfTopology().getVnfResourceAssignments().getVnfNetworks().getVnfNetwork().isEmpty()) {
1444                 log.info("First entry into network info.");
1445                 vnf.getVnfData().getVnfTopology().getVnfResourceAssignments().getVnfNetworks().addVnfNetworkItem(genericResourceApiVnfNetworkDataBodyParam);
1446                 responseStatus = HttpStatus.CREATED;
1447             } else {
1448                 log.info("Found networks. Filtering.");
1449                 vnf.getVnfData().getVnfTopology().getVnfResourceAssignments().getVnfNetworks().getVnfNetwork().stream()
1450                         .filter(targetNetwork -> !targetNetwork.getNetworkRole().equals(networkRole))
1451                         .forEach(networkList::addVnfNetworkItem);
1452                 networkList.addVnfNetworkItem(genericResourceApiVnfNetworkDataBodyParam);
1453
1454                 if(networkList.getVnfNetwork().size() != vnf.getVnfData().getVnfTopology().getVnfResourceAssignments().getVnfNetworks().getVnfNetwork().size()) {
1455                     log.info("Added a new Item");
1456                     responseStatus = HttpStatus.CREATED;
1457                 }
1458                 vnf.getVnfData().getVnfTopology().getVnfResourceAssignments().setVnfNetworks(networkList);
1459             }
1460
1461             vnflist.addVnfItem(vnf);
1462         }
1463
1464         svcData.setVnfs(vnflist);
1465         // Map and save the new data
1466         try {
1467             data.setSvcData(objectMapper.writeValueAsString(svcData));
1468             configServicesRepository.save(data);
1469             return new ResponseEntity<>(responseStatus);
1470         } catch(JsonProcessingException e) {
1471             log.error("Error mapping object to JSON", e);
1472             // Should probably be a 500 INTERNAL_SERVICE_ERROR
1473             return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
1474         }
1475     }
1476
1477     /**
1478      * Extracts a VNF object from the database,
1479      * @param configServices A Config Services option created from a Service
1480      *                       Instance ID
1481      * @param vnfId the target VNF ID
1482      * @return An empty Optional if the Service Data does not exist, an empty
1483      *         Optional if the VNF is not found, or an optional containing the
1484      *         found VNF.
1485      */
1486     private Optional<GenericResourceApiServicedataServicedataVnfsVnf> getVnfObject(ConfigServices configServices, String vnfId) {
1487         // Map the Marshall the JSON String into a Java Object
1488         log.info("Getting VNF Data for ({})", vnfId);
1489         GenericResourceApiServicedataServiceData svcData;
1490         try {
1491             svcData = objectMapper.readValue(configServices.getSvcData(), GenericResourceApiServicedataServiceData.class);
1492         } catch(JsonProcessingException e) {
1493             log.error("Error", e);
1494             return Optional.empty();
1495         }
1496
1497         /*Get a stream of the VNF Objects and return the target if it's found,
1498          * assuming that each VNF ID is unique within a Service Instance Object
1499          */
1500         return svcData.getVnfs().getVnf()
1501                        .stream()
1502                        .filter(targetVnf -> targetVnf.getVnfId().equals(vnfId))
1503                        .findFirst();
1504     }
1505
1506     @Override
1507     public ResponseEntity<GenericResourceApiServicetopologyServiceTopology> configGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceDataServiceTopologyGet(String serviceInstanceId) throws RestApplicationException, RestProtocolException {
1508         GenericResourceApiServicetopologyServiceTopology serviceTopology = null;
1509         GenericResourceApiServicedataServiceData serviceData = null;
1510
1511         List<ConfigServices> services = configServicesRepository.findBySvcInstanceId(serviceInstanceId);
1512         if ((services == null) || (services.isEmpty())) {
1513             throw new RestProtocolException("data-missing", "No service entry found", HttpStatus.NOT_FOUND.value());
1514         }
1515
1516         try {
1517             if ( services.get(0).getSvcData().isEmpty()) {
1518                 throw new RestProtocolException("data-missing", "No service-data entry found", HttpStatus.NOT_FOUND.value());
1519             } else {
1520                 serviceData = objectMapper.readValue(services.get(0).getSvcData(), GenericResourceApiServicedataServiceData.class);
1521                 serviceTopology = serviceData.getServiceTopology();
1522             }
1523             if (serviceTopology == null) {
1524                 throw new RestProtocolException("data-missing", "No service-topology entry found", HttpStatus.NOT_FOUND.value());
1525             }
1526             return new ResponseEntity<>(serviceTopology, HttpStatus.OK);
1527         } catch (JsonProcessingException e) {
1528             log.error("Could not parse service data", e);
1529             throw new RestApplicationException("data-conversion", "Request could not be completed due to internal error", e, HttpStatus.INTERNAL_SERVER_ERROR.value());
1530         }
1531
1532     }
1533
1534 }