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