starwit · witchpou · Feb 6, 2026 · Feb 4, 2026 · Feb 4, 2026 · Feb 4, 2026
diff --git a/src/main/java/de/muenchen/dave/repositories/relationaldb/ZeitintervallRepository.java b/src/main/java/de/muenchen/dave/repositories/relationaldb/ZeitintervallRepository.java
@@ -50,6 +50,11 @@ List<Zeitintervall> findByZaehlungIdAndStartUhrzeitGreaterThanEqualAndEndeUhrzei
             final LocalDateTime endeUhrzeit,
             final TypeZeitintervall type);
 
+    List<Zeitintervall> findByZaehlungIdAndStartUhrzeitGreaterThanEqualAndEndeUhrzeitLessThanEqualAndFahrbeziehungVonNotNullOrderBySortingIndexAsc(
+            final UUID zaehlungId,
+            final LocalDateTime startUhrzeit,
+            final LocalDateTime endeUhrzeit);
+
     List<Zeitintervall> findByZaehlungIdAndStartUhrzeitGreaterThanEqualAndEndeUhrzeitLessThanEqualAndFahrbeziehungVonAndFahrbeziehungNachAndFahrbeziehungFahrbewegungKreisverkehrAndTypeInOrderBySortingIndexAsc(
             final UUID zaehlungId,
             final LocalDateTime startUhrzeit,
@@ -59,6 +64,12 @@ List<Zeitintervall> findByZaehlungIdAndStartUhrzeitGreaterThanEqualAndEndeUhrzei
             final FahrbewegungKreisverkehr fahrbewegungKreisverkehr,
             final Set<TypeZeitintervall> types);
 
+    List<Zeitintervall> findByZaehlungIdAndStartUhrzeitGreaterThanEqualAndEndeUhrzeitLessThanEqualAndFahrbeziehungFahrbewegungKreisverkehrOrderBySortingIndexAsc(
+            final UUID zaehlungId,
+            final LocalDateTime startUhrzeit,
+            final LocalDateTime endeUhrzeit,
+            final FahrbewegungKreisverkehr fahrbewegungKreisverkehr);
+
     Zeitintervall findByZaehlungIdAndTypeAndFahrbeziehungVonAndFahrbeziehungNachAndStartUhrzeitGreaterThanEqualAndEndeUhrzeitLessThanEqualAndFahrbeziehungFahrbewegungKreisverkehrIsNull(
             final UUID zaehlungId,
             final TypeZeitintervall type,
@@ -67,6 +78,11 @@ Zeitintervall findByZaehlungIdAndTypeAndFahrbeziehungVonAndFahrbeziehungNachAndS
             final LocalDateTime startuhrzeit,
             final LocalDateTime endeuhrzeit);
 
+    List<Zeitintervall> findByZaehlungIdAndStartUhrzeitGreaterThanEqualAndEndeUhrzeitLessThanEqualAndFahrbeziehungFahrbewegungKreisverkehrIsNull(
+            final UUID zaehlungId,
+            final LocalDateTime startuhrzeit,
+            final LocalDateTime endeuhrzeit);
+
     /*
      * Extrahiert den Zeitintervall entsprechend des SortingIndex über alle vorhandenen Fahrbeziehungen.
      */

diff --git a/src/main/java/de/muenchen/dave/services/ladezaehldaten/LadeZaehldatenService.java b/src/main/java/de/muenchen/dave/services/ladezaehldaten/LadeZaehldatenService.java
@@ -15,6 +15,7 @@
 import de.muenchen.dave.exceptions.DataNotFoundException;
 import de.muenchen.dave.repositories.relationaldb.ZeitintervallRepository;
 import de.muenchen.dave.services.ZaehlstelleIndexService;
+import de.muenchen.dave.services.persist.ZeitintervallPersistierungsService;
 import de.muenchen.dave.util.CalculationUtil;
 import de.muenchen.dave.util.dataimport.ZeitintervallSortingIndexUtil;
 import java.math.BigDecimal;
@@ -57,10 +58,14 @@ public class LadeZaehldatenService {
 
     private final ZaehlstelleIndexService indexService;
 
+    private final ZeitintervallPersistierungsService zeitintervallPersistierungsService;
+
     public LadeZaehldatenService(final ZeitintervallRepository zeitintervallRepository,
-            final ZaehlstelleIndexService indexService) {
+            final ZaehlstelleIndexService indexService,
+            final ZeitintervallPersistierungsService zeitintervallPersistierungsService) {
         this.zeitintervallRepository = zeitintervallRepository;
         this.indexService = indexService;
+        this.zeitintervallPersistierungsService = zeitintervallPersistierungsService;
         // Kfz
         SPITZENSTUNDEN_BLOCK_SORTING_INDEX
                 .add(ZeitintervallSortingIndexUtil.SORTING_INDEX_ZB_00_06 + ZeitintervallSortingIndexUtil.getSortingIndexSpitzenStundeWithinBlockKfz());
@@ -318,9 +323,9 @@ public LadeZaehldatenTableDTO ladeZaehldaten(final UUID zaehlungId,
         final List<Zeitintervall> zeitintervalle;
         final Zaehlung zaehlung = indexService.getZaehlung(zaehlungId.toString());
         if (StringUtils.contains(options.getZeitauswahl(), ZEITAUSWAHL_SPITZENSTUNDE)) {
-            zeitintervalle = extractZeitintervalleForSpitzenstunde(zaehlungId, zaehlung.getKreisverkehr(), options);
+            zeitintervalle = extractZeitintervalleForSpitzenstunde(zaehlungId, zaehlung.getZaehldauer(), zaehlung.getKreisverkehr(), options);
         } else {
-            zeitintervalle = extractZeitintervalle(zaehlungId, zaehlung.getKreisverkehr(), options);
+            zeitintervalle = extractZeitintervalle(zaehlungId, zaehlung.getZaehldauer(), zaehlung.getKreisverkehr(), options);
         }
         final PkwEinheit pkwEinheit = zaehlung.getPkwEinheit();
         List<LadeZaehldatumDTO> ladeZaehldaten = zeitintervalle.stream()
@@ -332,12 +337,14 @@ public LadeZaehldatenTableDTO ladeZaehldaten(final UUID zaehlungId,
     }
 
     private List<Zeitintervall> extractZeitintervalle(final UUID zaehlungId,
+            final String zaehldauer,
             final Boolean isKreisverkehr,
             final OptionsDTO options) {
         final Set<TypeZeitintervall> types = getTypesAccordingChosenOptions(options);
         log.debug("Types according chosen options: {}", types);
         final List<Zeitintervall> extractedZeitintervalle = extractZeitintervalle(
                 zaehlungId,
+                zaehldauer,
                 options.getZeitblock().getStart(),
                 options.getZeitblock().getEnd(),
                 options.getVonKnotenarm(),
@@ -350,7 +357,8 @@ private List<Zeitintervall> extractZeitintervalle(final UUID zaehlungId,
                 .collect(Collectors.toList());
     }
 
-    public List<Zeitintervall> extractZeitintervalle(final UUID zaehlungId,
+    private List<Zeitintervall> extractZeitintervalle(final UUID zaehlungId,
+            final String zaehldauer,
             final LocalDateTime startUhrzeit,
             final LocalDateTime endeUhrzeit,
             final Integer von,
@@ -383,6 +391,7 @@ public List<Zeitintervall> extractZeitintervalle(final UUID zaehlungId,
         }
         return extractZeitintervalle(
                 zaehlungId,
+                zaehldauer,
                 startUhrzeit,
                 endeUhrzeit,
                 vonKnotenarm,
@@ -391,22 +400,30 @@ public List<Zeitintervall> extractZeitintervalle(final UUID zaehlungId,
                 types);
     }
 
-    public List<Zeitintervall> extractZeitintervalle(final UUID zaehlungId,
+    public List<Zeitintervall> extractZeitintervalle(
+            final UUID zaehlungId,
+            final String zaehldauer,
             final LocalDateTime startUhrzeit,
             final LocalDateTime endeUhrzeit,
             final Integer von,
             final Integer nach,
             final FahrbewegungKreisverkehr fahrbewegungKreisverkehr,
             final Set<TypeZeitintervall> types) {
-        return zeitintervallRepository
-                .findByZaehlungIdAndStartUhrzeitGreaterThanEqualAndEndeUhrzeitLessThanEqualAndFahrbeziehungVonAndFahrbeziehungNachAndFahrbeziehungFahrbewegungKreisverkehrAndTypeInOrderBySortingIndexAsc(
+
+        List<Zeitintervall> zi = zeitintervallRepository
+                .findByZaehlungIdAndStartUhrzeitGreaterThanEqualAndEndeUhrzeitLessThanEqualAndFahrbeziehungFahrbewegungKreisverkehrOrderBySortingIndexAsc(
                         zaehlungId,
                         startUhrzeit,
                         endeUhrzeit,
-                        von,
-                        nach,
-                        fahrbewegungKreisverkehr,
-                        types);
+                        fahrbewegungKreisverkehr);
+
+        zi = zeitintervallPersistierungsService.aufbereitenUndPersistieren(zi,
+                List.of(Zaehldauer.DAUER_2_X_4_STUNDEN, Zaehldauer.DAUER_13_STUNDEN, Zaehldauer.DAUER_16_STUNDEN)
+                        .contains(Zaehldauer.valueOf(zaehldauer)));
+
+        zi = zi.stream().filter(zeitintervall -> types.contains(zeitintervall.getType()) && zeitintervall.getFahrbeziehung().getVon() == von
+                && zeitintervall.getFahrbeziehung().getNach() == nach).collect(Collectors.toList());
+        return zi;
     }
 
     /**
@@ -419,9 +436,10 @@ public List<Zeitintervall> extractZeitintervalle(final UUID zaehlungId,
      *         gefolgt vom {@link Zeitintervall} der Spitzenstunde.
      */
     private List<Zeitintervall> extractZeitintervalleForSpitzenstunde(final UUID zaehlungId,
+            final String zaehldauer,
             final Boolean isKreisverkehr,
             final OptionsDTO options) {
-        final List<Zeitintervall> spitzenstunden = extractZeitintervalle(zaehlungId, isKreisverkehr, options);
+        final List<Zeitintervall> spitzenstunden = extractZeitintervalle(zaehlungId, zaehldauer, isKreisverkehr, options);
         final List<Zeitintervall> extractedZeitintervalle;
         if (!spitzenstunden.isEmpty()) {
             /*
@@ -434,6 +452,7 @@ private List<Zeitintervall> extractZeitintervalleForSpitzenstunde(final UUID zae
             final Zeitintervall spitzenStunde = spitzenstunden.get(spitzenstunden.size() - 1);
             extractedZeitintervalle = extractZeitintervalle(
                     zaehlungId,
+                    zaehldauer,
                     spitzenStunde.getStartUhrzeit(),
                     spitzenStunde.getEndeUhrzeit(),
                     options.getVonKnotenarm(),

diff --git a/src/main/java/de/muenchen/dave/services/persist/ZeitintervallPersistierungsService.java b/src/main/java/de/muenchen/dave/services/persist/ZeitintervallPersistierungsService.java
@@ -69,7 +69,7 @@ public boolean deleteZaehlung(final String zaehlungId) {
      *            Persistierung.
      * @param kiAufbereitung KI Aufbereitung ausführen (Nur für 2x4h Zählungen)
      */
-    public void aufbereitenUndPersistieren(final List<Zeitintervall> zeitintervalle, final boolean kiAufbereitung) {
+    public List<Zeitintervall> aufbereitenUndPersistieren(final List<Zeitintervall> zeitintervalle, final boolean kiAufbereitung) {
 
         /*
          * - Die im Parameter übergebenen Zeitintervalle werden überprüft,
@@ -137,7 +137,9 @@ public void aufbereitenUndPersistieren(final List<Zeitintervall> zeitintervalle,
         allZeitintervalle.addAll(summierteZeitbloecke);
         allZeitintervalle.addAll(kiZeitintervalle);
 
-        persistZeitintervalle(allZeitintervalle);
+        return allZeitintervalle;
+
+        //persistZeitintervalle(allZeitintervalle);
     }
 
     /**

diff --git a/...a/de/muenchen/dave/services/processzaehldaten/ProcessZaehldatenBelastungsplanService.java b/...a/de/muenchen/dave/services/processzaehldaten/ProcessZaehldatenBelastungsplanService.java
@@ -20,6 +20,7 @@
 import de.muenchen.dave.repositories.elasticsearch.ZaehlstelleIndex;
 import de.muenchen.dave.repositories.relationaldb.ZeitintervallRepository;
 import de.muenchen.dave.services.ladezaehldaten.LadeZaehldatenService;
+import de.muenchen.dave.services.persist.ZeitintervallPersistierungsService;
 import de.muenchen.dave.util.CalculationUtil;
 import de.muenchen.dave.util.dataimport.ZeitintervallGleitendeSpitzenstundeUtil;
 import de.muenchen.dave.util.dataimport.ZeitintervallSortingIndexUtil;
@@ -58,16 +59,20 @@ public class ProcessZaehldatenBelastungsplanService {
 
     private final ZeitintervallRepository zeitintervallRepository;
 
+    private final ZeitintervallPersistierungsService zeitintervallPersistierungsService;
+
     private final ZaehlstelleIndex zaehlstelleIndex;
 
     private final LadeZaehldatenService ladeZaehldatenService;
 
     public ProcessZaehldatenBelastungsplanService(final ZeitintervallRepository zeitintervallRepository,
             final ZaehlstelleIndex zaehlstelleIndex,
-            final LadeZaehldatenService ladeZaehldatenService) {
+            final LadeZaehldatenService ladeZaehldatenService,
+            final ZeitintervallPersistierungsService zeitintervallPersistierungsService) {
         this.zeitintervallRepository = zeitintervallRepository;
         this.zaehlstelleIndex = zaehlstelleIndex;
         this.ladeZaehldatenService = ladeZaehldatenService;
+        this.zeitintervallPersistierungsService = zeitintervallPersistierungsService;
     }
 
     /**
@@ -672,12 +677,18 @@ public LadeBelastungsplanDTO getDifferenzdatenBelastungsplanDTO(final String zae
 
     public List<Zeitintervall> extractZeitintervalle(final String zaehlungId,
             final OptionsDTO options) {
-        return zeitintervallRepository
-                .findByZaehlungIdAndStartUhrzeitGreaterThanEqualAndEndeUhrzeitLessThanEqualAndFahrbeziehungVonNotNullAndTypeOrderBySortingIndexAsc(
+        List<Zeitintervall> zi = zeitintervallRepository
+                .findByZaehlungIdAndStartUhrzeitGreaterThanEqualAndEndeUhrzeitLessThanEqualAndFahrbeziehungVonNotNullOrderBySortingIndexAsc(
                         UUID.fromString(zaehlungId),
                         options.getZeitblock().getStart(),
-                        options.getZeitblock().getEnd(),
-                        options.getZeitblock().getTypeZeitintervall());
+                        options.getZeitblock().getEnd());
+
+        zi = zeitintervallPersistierungsService.aufbereitenUndPersistieren(zi, false);
+        zi = zi.stream()
+                .filter(zeitintervall -> options.getZeitblock().getTypeZeitintervall() == zeitintervall.getType()
+                        && zeitintervall.getFahrbeziehung().getVon() != null)
+                .collect(Collectors.toList());
+        return zi;
     }
 
     /**
@@ -705,6 +716,7 @@ public List<Zeitintervall> extractZeitintervalleSpitzenstunde(final Zaehlung zae
         }
         final List<Zeitintervall> spitzenstunden = ladeZaehldatenService.extractZeitintervalle(
                 UUID.fromString(zaehlung.getId()),
+                zaehlung.getZaehldauer(),
                 options.getZeitblock().getStart(),
                 options.getZeitblock().getEnd(),
                 options.getVonKnotenarm(),

diff --git a/...n/java/de/muenchen/dave/services/processzaehldaten/ProcessZaehldatenZeitreiheService.java b/...n/java/de/muenchen/dave/services/processzaehldaten/ProcessZaehldatenZeitreiheService.java
@@ -18,6 +18,7 @@
 import de.muenchen.dave.services.ZeitauswahlService;
 import de.muenchen.dave.services.ladezaehldaten.LadeZaehldatenService;
 import de.muenchen.dave.services.pdfgenerator.FillPdfBeanService;
+import de.muenchen.dave.services.persist.ZeitintervallPersistierungsService;
 import java.math.BigDecimal;
 import java.time.LocalDate;
 import java.util.Comparator;
@@ -37,13 +38,16 @@ public class ProcessZaehldatenZeitreiheService {
     private final ZeitintervallRepository zeitintervallRepository;
     private final ZaehlstelleIndexService indexService;
     private final ZeitauswahlService zeitauswahlService;
+    private final ZeitintervallPersistierungsService zeitintervallPersistierungsService;
 
     public ProcessZaehldatenZeitreiheService(final ZaehlstelleIndexService indexService,
             final ZeitintervallRepository zeitintervallRepository,
-            final ZeitauswahlService zeitauswahlService) {
+            final ZeitauswahlService zeitauswahlService,
+            final ZeitintervallPersistierungsService zeitintervallPersistierungsService) {
         this.zeitauswahlService = zeitauswahlService;
         this.indexService = indexService;
         this.zeitintervallRepository = zeitintervallRepository;
+        this.zeitintervallPersistierungsService = zeitintervallPersistierungsService;
     }
 
     /**
@@ -202,18 +206,37 @@ public LadeZaehldatenZeitreiheDTO getZeitreiheDTO(final String currentZaehlungId
                         // auf der die Optionen basieren, eine 24-Std.-Zählung ist, diese allerdings mit 2x4-Std.-Zählungen verglichen wird
                         options.setZaehldauer(Zaehldauer.valueOf(zaehlung.getZaehldauer()));
 
-                        final Zeitintervall zeitintervall = zeitintervallRepository
-                                .findByZaehlungIdAndTypeAndFahrbeziehungVonAndFahrbeziehungNachAndStartUhrzeitGreaterThanEqualAndEndeUhrzeitLessThanEqualAndFahrbeziehungFahrbewegungKreisverkehrIsNull(
+                        List<Zeitintervall> zi = zeitintervallRepository
+                                .findByZaehlungIdAndStartUhrzeitGreaterThanEqualAndEndeUhrzeitLessThanEqualAndFahrbeziehungFahrbewegungKreisverkehrIsNull(
                                         UUID.fromString(zaehlung.getId()),
-                                        options.getZeitblock().getTypeZeitintervall(),
-                                        options.getVonKnotenarm(),
-                                        options.getNachKnotenarm(),
                                         options.getZeitblock().getStart(),
                                         options.getZeitblock().getEnd());
 
-                        final LadeZaehldatumDTO ladeZaehldatumDTO = LadeZaehldatenService.mapToZaehldatum(zeitintervall, zaehlung.getPkwEinheit(), options);
-                        ladeZaehldatenZeitreiheDTO.getDatum().add(zaehlung.getDatum().format(FillPdfBeanService.DDMMYYYY));
+                        zi = zeitintervallPersistierungsService.aufbereitenUndPersistieren(zi, false).stream()
+                                .filter(z -> filterZeitreihe(z, options))
+                                .collect(Collectors.toList());
 
+                        LadeZaehldatumDTO ladeZaehldatumDTO = new LadeZaehldatumDTO();
+
+                        if (zi.isEmpty()) {
+                            log.warn("Kein Zeitintervall gefunden für Zählung " + zaehlung.getId() + " mit den Parametern: Type "
+                                    + options.getZeitblock().getTypeZeitintervall() +
+                                    ", Von " + options.getVonKnotenarm() + ", Nach " + options.getNachKnotenarm() +
+                                    ", Start " + options.getZeitblock().getStart() + ", Ende " + options.getZeitblock().getEnd());
+
+                            ladeZaehldatumDTO.setPkw(0);
+                            ladeZaehldatumDTO.setLkw(0);
+                            ladeZaehldatumDTO.setLastzuege(0);
+                            ladeZaehldatumDTO.setBusse(0);
+                            ladeZaehldatumDTO.setKraftraeder(0);
+                            ladeZaehldatumDTO.setFahrradfahrer(0);
+                            ladeZaehldatumDTO.setFussgaenger(0);
+                            ladeZaehldatumDTO.setPkwEinheiten(0);
+                            ladeZaehldatenZeitreiheDTO.getDatum().add(zaehlung.getDatum().format(FillPdfBeanService.DDMMYYYY) + FAHRBEZIEHUNG_NICHT_VORHANDEN);
+                        } else {
+                            ladeZaehldatumDTO = LadeZaehldatenService.mapToZaehldatum(zi.getFirst(), zaehlung.getPkwEinheit(), options);
+                            ladeZaehldatenZeitreiheDTO.getDatum().add(zaehlung.getDatum().format(FillPdfBeanService.DDMMYYYY));
+                        }
                         fillLadeZaehldatenZeitreiheDTO(options, ladeZaehldatenZeitreiheDTO, ladeZaehldatumDTO);
                     } else {
                         final LadeZaehldatumDTO ladeZaehldatumDTO = new LadeZaehldatumDTO();
@@ -233,6 +256,14 @@ public LadeZaehldatenZeitreiheDTO getZeitreiheDTO(final String currentZaehlungId
         return ladeZaehldatenZeitreiheDTO;
     }
 
+    private boolean filterZeitreihe(Zeitintervall zi, OptionsDTO options) {
+        boolean matches = false;
+        matches = zi.getType() == options.getZeitblock().getTypeZeitintervall();
+        matches = matches && options.getVonKnotenarm() == zi.getFahrbeziehung().getVon();
+        matches = matches && options.getNachKnotenarm() == zi.getFahrbeziehung().getNach();
+        return matches;
+    }
+
     /**
      * Filtert die Zaehlungen aus der Zaehlstelle heraus, die in der Zeitreihe angezeigt werden sollen
      * und gibt diese als Stream zurück. Die Zaehlungen werden

diff --git a/src/test/java/de/muenchen/dave/services/ProcessZaehldatenBelastungsplanServiceTest.java b/src/test/java/de/muenchen/dave/services/ProcessZaehldatenBelastungsplanServiceTest.java
@@ -114,7 +114,7 @@ public void getBelastunsplanData() {
         zaehlung.setZaehlart(Zaehlart.N.toString());
         zaehlung.setKreisverkehr(false);
 
-        final Map<Fahrzeug, BelastungsplanDataDTO> belastungsplanData = new ProcessZaehldatenBelastungsplanService(null, null, null)
+        final Map<Fahrzeug, BelastungsplanDataDTO> belastungsplanData = new ProcessZaehldatenBelastungsplanService(null, null, null, null)
                 .getBelastungsplanData(zaehldatenJeFahrbeziehung, zaehlung);
 
         assertThat(belastungsplanData.get(Fahrzeug.KFZ).getValues()[1][2], is(BigDecimal.valueOf(15)));

diff --git a/src/test/java/de/muenchen/dave/spring/ProcessZaehldatenBelastungsplanServiceSpringTest.java b/src/test/java/de/muenchen/dave/spring/ProcessZaehldatenBelastungsplanServiceSpringTest.java
@@ -350,7 +350,7 @@ void extractZeitintervalleSpitzenstunde() {
         List<Zeitintervall> spitzenstunden = new ArrayList<>();
         spitzenstunden.add(spitzenstunde);
 
-        when(ladeZaehldatenService.extractZeitintervalle(any(), any(), any(), any(), any(), nullable(FahrbewegungKreisverkehr.class), anySet()))
+        when(ladeZaehldatenService.extractZeitintervalle(any(), any(), any(), any(), any(), any(), nullable(FahrbewegungKreisverkehr.class), anySet()))
                 .thenReturn(spitzenstunden);
 
         List<Zeitintervall> zeitintervalle = new ArrayList<>();