private void updateInterruptCapability(
     InterruptCapability interruptCapability, InterruptCapabilityDto interruptCapabilityDto) {
   interruptCapability.setMaxDtus(interruptCapabilityDto.getMaxDtus());
   interruptCapability.setType(
       UdiEventTransformer.transformToModel(interruptCapabilityDto.getType()));
   LOGGER.debug("Updated interrupt-capability with id [{}] ", interruptCapabilityDto.getId());
 }
 private void createUdiEventFromDto(UdiEventDto udiEventDto, LocalDate period) {
   Udi udi = udiRepository.findByEndpoint(udiEventDto.getUdiEndpoint(), period);
   UdiEvent udiEvent = UdiEventTransformer.transformToModel(udiEventDto, udi);
   udiEventRepository.persist(udiEvent);
   LOGGER.debug("Created new udi event with id [{}]", udiEvent.getId());
   udiEventDto
       .getDeviceCapabilities()
       .forEach(deviceCapabilityDto -> createDeviceCapability(deviceCapabilityDto, udiEvent));
 }
 private void updateUdiEventFromDto(UdiEvent originalUdiEvent, UdiEventDto udiEventDto) {
   // should not change but you never know, let's allow it for now
   originalUdiEvent.setPeriod(udiEventDto.getPeriod());
   originalUdiEvent.setUdiEventType(
       UdiEventTransformer.transformToModel(udiEventDto.getUdiEventType()));
   // may change
   originalUdiEvent.setStartDtu(udiEventDto.getStartDtu());
   originalUdiEvent.setEndDtu(udiEventDto.getEndDtu());
   originalUdiEvent.setStartAfterDtu(udiEventDto.getStartAfterDtu());
   originalUdiEvent.setFinishBeforeDtu(udiEventDto.getFinishBeforeDtu());
   originalUdiEvent.setDeviceSelector(udiEventDto.getDeviceSelector());
   Map<String, DeviceCapability> dbCapabilitiesPerId =
       originalUdiEvent
           .getDeviceCapabilities()
           .stream()
           .collect(Collectors.toMap(DeviceCapability::getId, Function.identity()));
   LOGGER.debug("Updated udi event with id [{}]", originalUdiEvent.getId());
   // update of create
   udiEventDto
       .getDeviceCapabilities()
       .stream()
       .forEach(
           deviceCapabilityDto -> {
             if (!dbCapabilitiesPerId.containsKey(deviceCapabilityDto.getId())) {
               createDeviceCapability(deviceCapabilityDto, originalUdiEvent);
             } else {
               updateDeviceCapability(
                   dbCapabilitiesPerId.get(deviceCapabilityDto.getId()), deviceCapabilityDto);
             }
           });
   // remove capabilities that are not given back in the updated id list
   Set<String> updatedCapabilitiesId =
       udiEventDto
           .getDeviceCapabilities()
           .stream()
           .map(DeviceCapabilityDto::getId)
           .collect(Collectors.toSet());
   dbCapabilitiesPerId
       .values()
       .stream()
       .filter(deviceCapability -> !updatedCapabilitiesId.contains(deviceCapability.getId()))
       .forEach(
           deviceCapability -> {
             LOGGER.debug(
                 "Deleted device capability with id [{}] for udi event with id [{}]",
                 deviceCapability.getId(),
                 deviceCapability.getUdiEvent().getId());
             originalUdiEvent.getDeviceCapabilities().remove(deviceCapability);
           });
 }
 private InterruptCapability createInterruptCapability(
     InterruptCapabilityDto interruptCapabilityDto, UdiEvent udiEvent) {
   InterruptCapability interruptCapability = new InterruptCapability();
   interruptCapability.setId(getDeviceCapabilityId(interruptCapabilityDto));
   interruptCapability.setMaxDtus(interruptCapabilityDto.getMaxDtus());
   interruptCapability.setType(
       UdiEventTransformer.transformToModel(interruptCapabilityDto.getType()));
   interruptCapability.setUdiEvent(udiEvent);
   interruptCapabilityRepository.persist(interruptCapability);
   LOGGER.debug(
       "Created new interrupt-capability with id [{}] for event with id [{}]",
       interruptCapabilityDto.getId(),
       udiEvent.getId());
   return interruptCapability;
 }
 private ReduceCapability createReduceCapability(
     ReduceCapabilityDto reduceCapabilityDto, UdiEvent udiEvent) {
   ReduceCapability reduceCapability = new ReduceCapability();
   reduceCapability.setId(getDeviceCapabilityId(reduceCapabilityDto));
   reduceCapability.setMaxDtus(reduceCapabilityDto.getMaxDtus());
   reduceCapability.setPowerStep(reduceCapabilityDto.getPowerStep());
   reduceCapability.setMinPower(reduceCapabilityDto.getMinPower());
   reduceCapability.setDurationMultiplier(reduceCapabilityDto.getDurationMultiplier());
   reduceCapability.setConsumptionProductionType(
       UdiEventTransformer.transformToModel(reduceCapabilityDto.getConsumptionProductionType()));
   reduceCapability.setUdiEvent(udiEvent);
   reduceCapabilityRepository.persist(reduceCapability);
   LOGGER.debug(
       "Created new reduce-capability with id [{}] for event with id [{}]",
       reduceCapabilityDto.getId(),
       udiEvent.getId());
   return reduceCapability;
 }
 private IncreaseCapability createIncreaseCapability(
     IncreaseCapabilityDto increaseCapabilityDto, UdiEvent udiEvent) {
   IncreaseCapability increaseCapability = new IncreaseCapability();
   increaseCapability.setId(getDeviceCapabilityId(increaseCapabilityDto));
   increaseCapability.setMaxDtus(increaseCapabilityDto.getMaxDtus());
   increaseCapability.setPowerStep(increaseCapabilityDto.getPowerStep());
   increaseCapability.setMaxPower(increaseCapabilityDto.getMaxPower());
   increaseCapability.setDurationMultiplier(increaseCapabilityDto.getDurationMultiplier());
   increaseCapability.setConsumptionProductionType(
       UdiEventTransformer.transformToModel(increaseCapabilityDto.getConsumptionProductionType()));
   increaseCapability.setUdiEvent(udiEvent);
   increaseCapabilityRepository.persist(increaseCapability);
   LOGGER.debug(
       "Created new increase-capability with id [{}] for event with id [{}]",
       increaseCapabilityDto.getId(),
       udiEvent.getId());
   return increaseCapability;
 }