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

   1 package org.onap.sdnc.apps.ms.gra.controllers;
   2
   3 import com.fasterxml.jackson.annotation.JsonInclude;
   4 import com.fasterxml.jackson.core.JsonProcessingException;
   5 import com.fasterxml.jackson.databind.ObjectMapper;
   6 import org.onap.sdnc.apps.ms.gra.data.*;
   7 import org.onap.sdnc.apps.ms.gra.swagger.OperationalApi;
   8 import org.onap.sdnc.apps.ms.gra.swagger.model.*;
   9 import org.slf4j.Logger;
  10 import org.slf4j.LoggerFactory;
  11 import org.springframework.beans.factory.annotation.Autowired;
  12 import org.springframework.boot.autoconfigure.domain.EntityScan;
  13 import org.springframework.context.annotation.ComponentScan;
  14 import org.springframework.http.HttpStatus;
  15 import org.springframework.http.ResponseEntity;
  16 import org.springframework.stereotype.Controller;
  17
  18 import javax.servlet.http.HttpServletRequest;
  19 import javax.validation.Valid;
  20 import java.util.Iterator;
  21 import java.util.List;
  22 import java.util.Optional;
  23 import java.util.concurrent.atomic.AtomicBoolean;
  24
  25 @Controller
  26 @ComponentScan(basePackages = {"org.onap.sdnc.apps.ms.gra.*"})
  27 @EntityScan("org.onap.sdnc.apps.ms.gra.springboot.*")
  28 public class OperationalApiController implements OperationalApi {
  29     private static final Logger log = LoggerFactory.getLogger(ConfigApiController.class);
  30
  31     private final ObjectMapper objectMapper;
  32
  33     private final HttpServletRequest request;
  34
  35     @Autowired
  36     private OperationalPreloadDataRepository operationalPreloadDataRepository;
  37
  38     @Autowired
  39     private OperationalServicesRepository operationalServicesRepository;
  40
  41     @Autowired
  42     public OperationalApiController(ObjectMapper objectMapper, HttpServletRequest request) {
  43         objectMapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
  44         objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
  45         this.objectMapper = objectMapper;
  46         this.request = request;
  47     }
  48
  49     @Override
  50     public Optional<ObjectMapper> getObjectMapper() {
  51         return Optional.ofNullable(objectMapper);
  52     }
  53
  54     @Override
  55     public Optional<HttpServletRequest> getRequest() {
  56         return Optional.ofNullable(request);
  57     }
  58
  59
  60     @Override
  61     public ResponseEntity<GenericResourceApiPreloadModelInformation> operationalGENERICRESOURCEAPIpreloadInformationGet() {
  62         GenericResourceApiPreloadModelInformation genericResourceApiPreloadModelInformation = new GenericResourceApiPreloadModelInformation();
  63
  64         operationalPreloadDataRepository.findAll().forEach(configPreloadData -> {
  65             GenericResourceApiPreloadmodelinformationPreloadList preloadListItem = new GenericResourceApiPreloadmodelinformationPreloadList();
  66
  67             preloadListItem.setPreloadId(configPreloadData.getPreloadId());
  68             preloadListItem.setPreloadType(configPreloadData.getPreloadType());
  69             try {
  70                 preloadListItem.setPreloadData(objectMapper.readValue(configPreloadData.getPreloadData(), GenericResourceApiPreloaddataPreloadData.class));
  71             } catch (JsonProcessingException e) {
  72                 log.error("Could not convert preload data", e);
  73             }
  74             genericResourceApiPreloadModelInformation.addPreloadListItem(preloadListItem);
  75         });
  76
  77
  78         return new ResponseEntity<>(genericResourceApiPreloadModelInformation, HttpStatus.OK);
  79     }
  80
  81
  82     @Override
  83     public ResponseEntity<GenericResourceApiPreloadmodelinformationPreloadList> operationalGENERICRESOURCEAPIpreloadInformationPreloadListPreloadIdPreloadTypeGet(String preloadId, String preloadType) {
  84         List<OperationalPreloadData> preloadData = operationalPreloadDataRepository.findByPreloadIdAndPreloadType(preloadId, preloadType);
  85         if (preloadData != null) {
  86             if (!preloadData.isEmpty()) {
  87                 OperationalPreloadData preloadDataItem = preloadData.get(0);
  88                 GenericResourceApiPreloadmodelinformationPreloadList preloadDataList = new GenericResourceApiPreloadmodelinformationPreloadList();
  89                 preloadDataList.setPreloadId(preloadDataItem.getPreloadId());
  90                 preloadDataList.setPreloadType(preloadDataItem.getPreloadType());
  91                 try {
  92                     preloadDataList.setPreloadData(objectMapper.readValue(preloadDataItem.getPreloadData(), GenericResourceApiPreloaddataPreloadData.class));
  93                 } catch (JsonProcessingException e) {
  94                     log.error("Cannot convert preload data", e);
  95                 }
  96                 return new ResponseEntity<>(preloadDataList, HttpStatus.OK);
  97             }
  98         }
  99         return new ResponseEntity<>(HttpStatus.NOT_FOUND);
 100     }
 101
 102
 103     @Override
 104     public ResponseEntity<GenericResourceApiPreloaddataPreloadData> operationalGENERICRESOURCEAPIpreloadInformationPreloadListPreloadIdPreloadTypePreloadDataGet(String preloadId, String preloadType) {
 105         List<OperationalPreloadData> preloadData = operationalPreloadDataRepository.findByPreloadIdAndPreloadType(preloadId, preloadType);
 106         if (preloadData != null) {
 107             if (!preloadData.isEmpty()) {
 108                 OperationalPreloadData preloadDataItem = preloadData.get(0);
 109                 try {
 110                     return new ResponseEntity<>(objectMapper.readValue(preloadDataItem.getPreloadData(), GenericResourceApiPreloaddataPreloadData.class), HttpStatus.OK);
 111                 } catch (JsonProcessingException e) {
 112                     log.error("Cannot convert preload data", e);
 113                 }
 114             }
 115         }
 116         return new ResponseEntity<>(HttpStatus.NOT_FOUND);
 117     }
 118
 119
 120     @Override
 121     public ResponseEntity<GenericResourceApiServiceModelInfrastructure> operationalGENERICRESOURCEAPIservicesGet() {
 122         GenericResourceApiServiceModelInfrastructure modelInfrastructure = new GenericResourceApiServiceModelInfrastructure();
 123
 124         AtomicBoolean caughtError = new AtomicBoolean(false);
 125         operationalServicesRepository.findAll().forEach(service ->
 126         {
 127             GenericResourceApiServicemodelinfrastructureService serviceItem = new GenericResourceApiServicemodelinfrastructureService();
 128             serviceItem.setServiceInstanceId(service.getSvcInstanceId());
 129             try {
 130                 serviceItem.setServiceData(objectMapper.readValue(service.getSvcData(), GenericResourceApiServicedataServiceData.class));
 131             } catch (JsonProcessingException e) {
 132                 log.error("Could not deserialize service data for {}", service.getSvcInstanceId(), e);
 133                 caughtError.set(true);
 134             }
 135             serviceItem.setServiceStatus(service.getServiceStatus());
 136             modelInfrastructure.addServiceItem(serviceItem);
 137         });
 138
 139         if (caughtError.get()) {
 140             return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
 141         } else {
 142             return new ResponseEntity<>(modelInfrastructure, HttpStatus.OK);
 143         }
 144     }
 145
 146
 147
 148     @Override
 149     public ResponseEntity<GenericResourceApiServicemodelinfrastructureService> operationalGENERICRESOURCEAPIservicesServiceServiceInstanceIdGet(String serviceInstanceId) {
 150         GenericResourceApiServicemodelinfrastructureService retval = null;
 151
 152         List<OperationalServices> services = operationalServicesRepository.findBySvcInstanceId(serviceInstanceId);
 153
 154         if (services.isEmpty()) {
 155             return new ResponseEntity<> (HttpStatus.NOT_FOUND);
 156         } else {
 157             OperationalServices service = services.get(0);
 158             retval = new GenericResourceApiServicemodelinfrastructureService();
 159             retval.setServiceInstanceId(serviceInstanceId);
 160             retval.setServiceStatus(service.getServiceStatus());
 161             try {
 162                 retval.setServiceData(objectMapper.readValue(service.getSvcData(), GenericResourceApiServicedataServiceData.class));
 163             } catch (JsonProcessingException e) {
 164                 log.error("Could not deserialize service data for service instance id {}", serviceInstanceId, e);
 165                 retval = null;
 166             }
 167         }
 168
 169         if (retval == null) {
 170             return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
 171         } else {
 172             return new ResponseEntity<>(retval, HttpStatus.OK);
 173         }
 174     }
 175
 176
 177     @Override
 178     public ResponseEntity<GenericResourceApiServicedataServiceData> operationalGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceDataGet(String serviceInstanceId) {
 179         GenericResourceApiServicedataServiceData serviceData = null;
 180
 181         List<OperationalServices> services = operationalServicesRepository.findBySvcInstanceId(serviceInstanceId);
 182         if (services.isEmpty()) {
 183             return new ResponseEntity<>(HttpStatus.NOT_FOUND);
 184         } else {
 185             try {
 186                 serviceData = objectMapper.readValue(services.get(0).getSvcData(), GenericResourceApiServicedataServiceData.class);
 187                 return new ResponseEntity<>(serviceData, HttpStatus.OK);
 188             } catch (JsonProcessingException e) {
 189                 log.error("Could not parse service data", e);
 190                 return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
 191             }
 192         }
 193     }
 194
 195     @Override
 196     public ResponseEntity<GenericResourceApiServicestatusServiceStatus> operationalGENERICRESOURCEAPIservicesServiceServiceInstanceIdServiceStatusGet(String serviceInstanceId) {
 197         GenericResourceApiServicestatusServiceStatus serviceStatus = null;
 198         List<OperationalServices> services = operationalServicesRepository.findBySvcInstanceId(serviceInstanceId);
 199
 200         if (!services.isEmpty()) {
 201             OperationalServices service = services.get(0);
 202             serviceStatus = service.getServiceStatus();
 203         }
 204
 205         if (serviceStatus == null) {
 206             return new ResponseEntity<>(HttpStatus.NOT_FOUND);
 207         } else {
 208             return new ResponseEntity<>(serviceStatus, HttpStatus.OK);
 209         }
 210
 211     }
 212
 213 }