Bugfixes im Dating und im Profil

src/main/java/de/oaa/xxx/dating/DatingController.java

@@ -7,41 +7,54 @@ import de.oaa.xxx.user.Neigung;
 import de.oaa.xxx.user.UserEntity;
 import de.oaa.xxx.user.UserRepository;
 import de.oaa.xxx.user.UserService;
+import de.oaa.xxx.vorlieben.UserVorliebeRepository;
+import de.oaa.xxx.vorlieben.VorliebeItemEntity;
+import de.oaa.xxx.vorlieben.VorliebeItemRepository;
+import de.oaa.xxx.vorlieben.VorliebeBewertung;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.server.ResponseStatusException;
 
 import java.security.Principal;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.UUID;
+import java.util.*;
+import java.util.stream.Collectors;
 
 @RestController
 @RequestMapping("/dating")
 public class DatingController {
 
+    private static final Set<VorliebeBewertung> POSITIVE_RATINGS = Set.of(
+            VorliebeBewertung.MAG_ICH, VorliebeBewertung.UNBEDINGT, VorliebeBewertung.WILL_AUSPROBIEREN);
+
     private final DatingService datingService;
     private final UserService userService;
     private final UserRepository userRepository;
     private final DatingPassRepository passRepository;
     private final SubscriptionLimitService subscriptionLimitService;
     private final SseService sseService;
+    private final UserVorliebeRepository userVorliebeRepository;
+    private final VorliebeItemRepository vorliebeItemRepository;
 
     public DatingController(DatingService datingService, UserService userService,
                              UserRepository userRepository,
                              DatingPassRepository passRepository,
                              SubscriptionLimitService subscriptionLimitService,
-                             SseService sseService) {
+                             SseService sseService,
+                             UserVorliebeRepository userVorliebeRepository,
+                             VorliebeItemRepository vorliebeItemRepository) {
         this.datingService = datingService;
         this.userService = userService;
         this.userRepository = userRepository;
         this.passRepository = passRepository;
         this.subscriptionLimitService = subscriptionLimitService;
         this.sseService = sseService;
+        this.userVorliebeRepository = userVorliebeRepository;
+        this.vorliebeItemRepository = vorliebeItemRepository;
     }
 
+    record VorliebeChipDto(String name, String bewertung) {}
+
     // ── Profilsuche ───────────────────────────────────────────────────────────
 
     @GetMapping("/profile-ids")
@@ -168,6 +181,61 @@ public class DatingController {
         return ResponseEntity.ok(datingService.getMatches(me.getUserId()));
     }
 
+    /**
+     * Prüft ob ein Match mit dem angegebenen User besteht.
+     */
+    @GetMapping("/match/{userId}")
+    public ResponseEntity<Map<String, Boolean>> checkMatch(
+            @PathVariable UUID userId, Principal principal) {
+        UserEntity me = userService.requireUser(principal);
+        boolean isMatch = datingService.isMatch(me.getUserId(), userId);
+        return ResponseEntity.ok(Map.of("isMatch", isMatch));
+    }
+
+    /**
+     * Match mit dem angegebenen User auflösen (beide Likes werden entfernt).
+     */
+    @DeleteMapping("/match/{userId}")
+    public ResponseEntity<Void> unmatch(
+            @PathVariable UUID userId, Principal principal) {
+        UserEntity me = userService.requireUser(principal);
+        datingService.unmatch(me.getUserId(), userId);
+        return ResponseEntity.noContent().build();
+    }
+
+    /**
+     * Gibt bis zu 5 zufällige positive Vorlieben (MAG_ICH, UNBEDINGT, WILL_AUSPROBIEREN)
+     * eines Users zurück – für die Profilvorschau im Dating-Bereich.
+     */
+    @GetMapping("/vorlieben/{userId}")
+    public ResponseEntity<List<VorliebeChipDto>> getDatingVorlieben(
+            @PathVariable UUID userId, Principal principal) {
+        userService.requireUser(principal);
+
+        var positive = userVorliebeRepository.findByUserId(userId).stream()
+                .filter(uv -> POSITIVE_RATINGS.contains(uv.getBewertung()))
+                .collect(Collectors.toList());
+
+        if (positive.isEmpty()) return ResponseEntity.ok(List.of());
+
+        Collections.shuffle(positive);
+        List<UUID> sampleIds = positive.stream()
+                .limit(5)
+                .map(de.oaa.xxx.vorlieben.UserVorliebeEntity::getItemId)
+                .toList();
+
+        Map<UUID, String> nameById = vorliebeItemRepository.findAllById(sampleIds).stream()
+                .collect(Collectors.toMap(VorliebeItemEntity::getItemId, VorliebeItemEntity::getName));
+
+        List<VorliebeChipDto> result = positive.stream()
+                .limit(5)
+                .filter(uv -> nameById.containsKey(uv.getItemId()))
+                .map(uv -> new VorliebeChipDto(nameById.get(uv.getItemId()), uv.getBewertung().name()))
+                .toList();
+
+        return ResponseEntity.ok(result);
+    }
+
     // ── Helpers ───────────────────────────────────────────────────────────────
 
     private UserEntity requireDatingUser(Principal principal) {

src/main/java/de/oaa/xxx/dating/DatingDateCleanupTask.java

@@ -0,0 +1,43 @@
+package de.oaa.xxx.dating;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * Löscht täglich abgelaufene Dates und deren Interessenten-Einträge.
+ * - Dates mit Termin: laufen nach dem Termin ab (expiresAt = scheduledAt)
+ * - Dates ohne Termin: laufen 30 Tage nach Erstellung ab (expiresAt = createdAt + 30 Tage)
+ */
+@Component
+public class DatingDateCleanupTask {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(DatingDateCleanupTask.class);
+
+    private final DatingDateRepository dateRepository;
+    private final DatingDateInterestRepository interestRepository;
+
+    public DatingDateCleanupTask(DatingDateRepository dateRepository,
+                                  DatingDateInterestRepository interestRepository) {
+        this.dateRepository     = dateRepository;
+        this.interestRepository = interestRepository;
+    }
+
+    @Scheduled(cron = "0 0 3 * * *") // täglich um 03:00 Uhr
+    @Transactional
+    public void deleteExpiredDates() {
+        List<DatingDateEntity> expired = dateRepository.findAllByExpiresAtBefore(LocalDateTime.now());
+        if (expired.isEmpty()) return;
+
+        for (DatingDateEntity date : expired) {
+            interestRepository.deleteByDateId(date.getDateId());
+        }
+        dateRepository.deleteAll(expired);
+        LOGGER.info("Dating-Cleanup: {} abgelaufene Date(s) gelöscht", expired.size());
+    }
+}

src/main/java/de/oaa/xxx/dating/DatingDateController.java

@@ -0,0 +1,396 @@
+package de.oaa.xxx.dating;
+
+import de.oaa.xxx.social.SystemMessageService;
+import de.oaa.xxx.social.entity.MessageCause;
+import de.oaa.xxx.social.repository.BlockRepository;
+import de.oaa.xxx.subscription.SubscriptionLimitService;
+import de.oaa.xxx.user.Geschlecht;
+import de.oaa.xxx.user.Neigung;
+import de.oaa.xxx.user.UserEntity;
+import de.oaa.xxx.user.UserRepository;
+import de.oaa.xxx.user.UserService;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.security.Principal;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/dating/dates")
+public class DatingDateController {
+
+    private static final int MAX_DATES_STANDARD = 1;
+    private static final int MAX_DATES_PRO      = 5;
+
+    private final DatingDateRepository dateRepository;
+    private final DatingDateInterestRepository interestRepository;
+    private final DatingService datingService;
+    private final UserService userService;
+    private final UserRepository userRepository;
+    private final BlockRepository blockRepository;
+    private final SubscriptionLimitService subscriptionLimitService;
+    private final SystemMessageService systemMessageService;
+
+    public DatingDateController(DatingDateRepository dateRepository,
+                                DatingDateInterestRepository interestRepository,
+                                DatingService datingService,
+                                UserService userService,
+                                UserRepository userRepository,
+                                BlockRepository blockRepository,
+                                SubscriptionLimitService subscriptionLimitService,
+                                SystemMessageService systemMessageService) {
+        this.dateRepository          = dateRepository;
+        this.interestRepository      = interestRepository;
+        this.datingService           = datingService;
+        this.userService             = userService;
+        this.userRepository          = userRepository;
+        this.blockRepository         = blockRepository;
+        this.subscriptionLimitService = subscriptionLimitService;
+        this.systemMessageService    = systemMessageService;
+    }
+
+    // ── DTOs ──────────────────────────────────────────────────────────────────
+
+    record DatingDateDto(
+            UUID dateId,
+            UUID creatorId,
+            String creatorName,
+            String creatorProfilePicture,
+            String title,
+            String description,
+            String imageData,
+            LocalDateTime scheduledAt,
+            LocalDateTime createdAt,
+            int interestCount,
+            boolean myInterest
+    ) {}
+
+    record DatesResult(List<DatingDateDto> mine, List<DatingDateDto> available) {}
+
+    record CreateDateRequest(String title, String description, String imageData, LocalDateTime scheduledAt) {}
+
+    record InterestResult(boolean myInterest, int interestCount) {}
+
+    record DateInterestDto(UUID userId, String name, String profilePicture, LocalDateTime interestedAt, boolean blocked) {}
+
+    // ── Dates abrufen ─────────────────────────────────────────────────────────
+
+    /**
+     * Gibt eigene Dates (ungefiltert) + verfügbare Dates (gefiltert nach Suchkriterien) zurück.
+     * Erfordert Dating aktiv + Standort (gleiche Voraussetzung wie Entdecken-Tab).
+     */
+    @GetMapping
+    public ResponseEntity<DatesResult> getDates(
+            @RequestParam(name = "maxDistanceKm", defaultValue = "50")    int maxDistanceKm,
+            @RequestParam(name = "minAge",         defaultValue = "18")    int minAge,
+            @RequestParam(name = "maxAge",         defaultValue = "99")    int maxAge,
+            @RequestParam(name = "geschlechter",   required = false)       List<String> geschlechter,
+            @RequestParam(name = "neigungen",      required = false)       List<String> neigungen,
+            @RequestParam(name = "vorliebenIds",   required = false)       List<UUID> vorliebenIds,
+            @RequestParam(name = "vorliebenUnd",   defaultValue = "false") boolean vorliebenUnd,
+            Principal principal) {
+
+        UserEntity me = requireDatingUser(principal);
+        UUID myId = me.getUserId();
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // Meine eigenen Dates (aktive)
+        List<DatingDateEntity> myDates = dateRepository.findByCreatorIdOrderByCreatedAtDesc(myId).stream()
+                .filter(d -> d.getExpiresAt().isAfter(now))
+                .toList();
+
+        // Alle fremden, noch nicht abgelaufenen Dates
+        List<DatingDateEntity> candidates = dateRepository.findAvailableExcluding(myId, now);
+
+        // Ersteller-IDs filtern (gleiche Kriterien wie Entdecken-Tab)
+        Set<UUID> creatorIds = candidates.stream().map(DatingDateEntity::getCreatorId).collect(Collectors.toSet());
+        DatingService.DatingFilter filter = new DatingService.DatingFilter(
+                Math.max(maxDistanceKm, 1),
+                Math.max(minAge, 0),
+                Math.min(maxAge, 120),
+                parseEnumList(geschlechter, Geschlecht.class),
+                parseEnumList(neigungen, Neigung.class),
+                vorliebenIds != null ? vorliebenIds : List.of(),
+                vorliebenUnd
+        );
+        Set<UUID> matchingCreators = datingService.filterUserIds(creatorIds, filter,
+                me.getDatingLat(), me.getDatingLon());
+
+        List<DatingDateEntity> available = candidates.stream()
+                .filter(d -> matchingCreators.contains(d.getCreatorId()))
+                .toList();
+
+        // Creator-User-Daten laden
+        Set<UUID> allCreatorIds = new HashSet<>(creatorIds);
+        myDates.forEach(d -> allCreatorIds.add(d.getCreatorId()));
+        Map<UUID, UserEntity> creators = userRepository.findAllById(allCreatorIds).stream()
+                .collect(Collectors.toMap(UserEntity::getUserId, u -> u));
+
+        // Alle relevanten Date-IDs
+        Set<UUID> allDateIds = new HashSet<>();
+        myDates.forEach(d -> allDateIds.add(d.getDateId()));
+        available.forEach(d -> allDateIds.add(d.getDateId()));
+
+        // Meine Interessen und Interest-Counts
+        Set<UUID> myInterests = new HashSet<>();
+        Map<UUID, Long> interestCounts = new HashMap<>();
+        for (UUID dateId : allDateIds) {
+            if (interestRepository.existsByDateIdAndUserId(dateId, myId)) myInterests.add(dateId);
+            interestCounts.put(dateId, interestRepository.countByDateId(dateId));
+        }
+
+        List<DatingDateDto> mineDtos = myDates.stream()
+                .map(d -> toDto(d, creators, myInterests, interestCounts))
+                .toList();
+
+        List<DatingDateDto> availableDtos = available.stream()
+                .map(d -> toDto(d, creators, myInterests, interestCounts))
+                .toList();
+
+        return ResponseEntity.ok(new DatesResult(mineDtos, availableDtos));
+    }
+
+    // ── Dates eines bestimmten Users abrufen (Profilansicht) ─────────────────
+
+    /**
+     * Gibt die aktiven Dates eines bestimmten Users zurück.
+     * Nur abrufbar, wenn der anfragende User selbst Dating aktiviert hat.
+     */
+    @GetMapping("/by-user/{userId}")
+    public ResponseEntity<List<DatingDateDto>> getDatesByUser(
+            @PathVariable("userId") UUID userId,
+            Principal principal) {
+
+        UserEntity me = requireDatingUser(principal);
+        LocalDateTime now = LocalDateTime.now();
+
+        List<DatingDateEntity> dates = dateRepository.findByCreatorIdOrderByCreatedAtDesc(userId).stream()
+                .filter(d -> d.getExpiresAt().isAfter(now))
+                .toList();
+
+        if (dates.isEmpty()) return ResponseEntity.ok(List.of());
+
+        UserEntity creator = userRepository.findById(userId).orElse(null);
+        Map<UUID, UserEntity> creators = creator != null ? Map.of(userId, creator) : Map.of();
+
+        Set<UUID> myInterests = new HashSet<>();
+        Map<UUID, Long> interestCounts = new HashMap<>();
+        for (DatingDateEntity d : dates) {
+            if (interestRepository.existsByDateIdAndUserId(d.getDateId(), me.getUserId()))
+                myInterests.add(d.getDateId());
+            interestCounts.put(d.getDateId(), interestRepository.countByDateId(d.getDateId()));
+        }
+
+        return ResponseEntity.ok(dates.stream()
+                .map(d -> toDto(d, creators, myInterests, interestCounts))
+                .toList());
+    }
+
+    // ── Date erstellen ────────────────────────────────────────────────────────
+
+    @PostMapping
+    public ResponseEntity<DatingDateDto> createDate(@RequestBody CreateDateRequest req, Principal principal) {
+        UserEntity me = requireDatingUser(principal);
+
+        if (req.title() == null || req.title().isBlank())
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Titel fehlt");
+        if (req.description() == null || req.description().isBlank())
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Beschreibung fehlt");
+        if (req.title().length() > 200)
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Titel zu lang");
+
+        boolean pro = subscriptionLimitService.hasActivePaidSubscription(me.getUserId());
+        int maxDates = pro ? MAX_DATES_PRO : MAX_DATES_STANDARD;
+        long existing = dateRepository.countByCreatorId(me.getUserId());
+        if (existing >= maxDates) {
+            throw new ResponseStatusException(HttpStatus.UNPROCESSABLE_ENTITY,
+                    pro ? "Maximal 5 Dates erlaubt (Pro)" : "Als Standardmitglied ist nur 1 Date erlaubt");
+        }
+
+        LocalDateTime now = LocalDateTime.now();
+        LocalDateTime expiresAt = req.scheduledAt() != null ? req.scheduledAt() : now.plusDays(30);
+
+        DatingDateEntity entity = new DatingDateEntity();
+        entity.setDateId(UUID.randomUUID());
+        entity.setCreatorId(me.getUserId());
+        entity.setTitle(req.title().strip());
+        entity.setDescription(req.description().strip());
+        entity.setImageData(req.imageData());
+        entity.setScheduledAt(req.scheduledAt());
+        entity.setCreatedAt(now);
+        entity.setExpiresAt(expiresAt);
+        dateRepository.save(entity);
+
+        Map<UUID, UserEntity> creators = Map.of(me.getUserId(), me);
+        return ResponseEntity.status(HttpStatus.CREATED)
+                .body(toDto(entity, creators, Set.of(), Map.of(entity.getDateId(), 0L)));
+    }
+
+    // ── Date bearbeiten ───────────────────────────────────────────────────────
+
+    @PutMapping("/{dateId}")
+    public ResponseEntity<DatingDateDto> updateDate(@PathVariable("dateId") UUID dateId,
+                                                    @RequestBody CreateDateRequest req,
+                                                    Principal principal) {
+        UserEntity me = requireDatingUser(principal);
+        DatingDateEntity entity = requireMyDate(dateId, me.getUserId());
+
+        if (req.title() == null || req.title().isBlank())
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Titel fehlt");
+        if (req.description() == null || req.description().isBlank())
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Beschreibung fehlt");
+        if (req.title().length() > 200)
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Titel zu lang");
+
+        entity.setTitle(req.title().strip());
+        entity.setDescription(req.description().strip());
+        if (req.imageData() != null) entity.setImageData(req.imageData().isBlank() ? null : req.imageData());
+        entity.setScheduledAt(req.scheduledAt());
+        entity.setExpiresAt(req.scheduledAt() != null ? req.scheduledAt() : entity.getCreatedAt().plusDays(30));
+        dateRepository.save(entity);
+
+        long count = interestRepository.countByDateId(dateId);
+        boolean myInterest = interestRepository.existsByDateIdAndUserId(dateId, me.getUserId());
+        Map<UUID, UserEntity> creators = Map.of(me.getUserId(), me);
+        return ResponseEntity.ok(toDto(entity, creators, myInterest ? Set.of(dateId) : Set.of(),
+                Map.of(dateId, count)));
+    }
+
+    // ── Date löschen ──────────────────────────────────────────────────────────
+
+    @DeleteMapping("/{dateId}")
+    @Transactional
+    public ResponseEntity<Void> deleteDate(@PathVariable("dateId") UUID dateId, Principal principal) {
+        UserEntity me = requireDatingUser(principal);
+        requireMyDate(dateId, me.getUserId());
+        interestRepository.deleteByDateId(dateId);
+        dateRepository.deleteById(dateId);
+        return ResponseEntity.noContent().build();
+    }
+
+    // ── Interesse bekunden / zurückziehen ──────────────────────────────────────
+
+    @PostMapping("/{dateId}/interest")
+    @Transactional
+    public ResponseEntity<InterestResult> toggleInterest(@PathVariable("dateId") UUID dateId,
+                                                         Principal principal) {
+        UserEntity me = userService.requireUser(principal);
+        DatingDateEntity date = dateRepository.findById(dateId)
+                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "Date nicht gefunden"));
+
+        if (date.getCreatorId().equals(me.getUserId()))
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Eigenes Date");
+        if (date.getExpiresAt().isBefore(LocalDateTime.now()))
+            throw new ResponseStatusException(HttpStatus.GONE, "Date abgelaufen");
+
+        Optional<DatingDateInterestEntity> existing =
+                interestRepository.findByDateIdAndUserId(dateId, me.getUserId());
+
+        boolean myInterest;
+        if (existing.isPresent()) {
+            interestRepository.delete(existing.get());
+            myInterest = false;
+        } else {
+            DatingDateInterestEntity interest = new DatingDateInterestEntity();
+            interest.setInterestId(UUID.randomUUID());
+            interest.setDateId(dateId);
+            interest.setUserId(me.getUserId());
+            interest.setInterestedAt(LocalDateTime.now());
+            interestRepository.save(interest);
+            myInterest = true;
+
+            // Benachrichtigung an Ersteller
+            String text = me.getName() + " hat Interesse an deinem Date \"" + date.getTitle() + "\" bekundet.";
+            systemMessageService.send(me.getUserId(), date.getCreatorId(), text,
+                    "/dating.html?tab=dates", MessageCause.DATE_INTEREST);
+        }
+
+        long count = interestRepository.countByDateId(dateId);
+        return ResponseEntity.ok(new InterestResult(myInterest, (int) count));
+    }
+
+    // ── Interessenten abrufen (nur Ersteller) ─────────────────────────────────
+
+    @GetMapping("/{dateId}/interests")
+    public ResponseEntity<List<DateInterestDto>> getInterests(@PathVariable("dateId") UUID dateId,
+                                                              Principal principal) {
+        UserEntity me = userService.requireUser(principal);
+        DatingDateEntity date = dateRepository.findById(dateId)
+                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "Date nicht gefunden"));
+
+        if (!date.getCreatorId().equals(me.getUserId()))
+            throw new ResponseStatusException(HttpStatus.FORBIDDEN, "Kein Zugriff");
+
+        List<DatingDateInterestEntity> interests = interestRepository.findByDateIdOrderByInterestedAtDesc(dateId);
+        Set<UUID> userIds = interests.stream().map(DatingDateInterestEntity::getUserId).collect(Collectors.toSet());
+        Map<UUID, UserEntity> users = userRepository.findAllById(userIds).stream()
+                .collect(Collectors.toMap(UserEntity::getUserId, u -> u));
+
+        List<DateInterestDto> dtos = interests.stream()
+                .map(i -> {
+                    UserEntity u = users.get(i.getUserId());
+                    if (u == null) return null;
+                    boolean blocked = blockRepository.existsBlock(me.getUserId(), u.getUserId());
+                    return new DateInterestDto(u.getUserId(), u.getName(),
+                            u.getProfilePicture(), i.getInterestedAt(), blocked);
+                })
+                .filter(Objects::nonNull)
+                .toList();
+
+        return ResponseEntity.ok(dtos);
+    }
+
+    // ── Helpers ───────────────────────────────────────────────────────────────
+
+    private UserEntity requireDatingUser(Principal principal) {
+        UserEntity me = userService.requireUser(principal);
+        if (!me.isDatingAktiv())
+            throw new ResponseStatusException(HttpStatus.FORBIDDEN, "Dating nicht aktiviert");
+        if (me.getDatingLat() == null || me.getDatingLon() == null)
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Standort nicht gesetzt");
+        return me;
+    }
+
+    private DatingDateEntity requireMyDate(UUID dateId, UUID userId) {
+        DatingDateEntity entity = dateRepository.findById(dateId)
+                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "Date nicht gefunden"));
+        if (!entity.getCreatorId().equals(userId))
+            throw new ResponseStatusException(HttpStatus.FORBIDDEN, "Kein Zugriff");
+        return entity;
+    }
+
+    private DatingDateDto toDto(DatingDateEntity d, Map<UUID, UserEntity> creators,
+                                 Set<UUID> myInterests, Map<UUID, Long> interestCounts) {
+        UserEntity creator = creators.get(d.getCreatorId());
+        return new DatingDateDto(
+                d.getDateId(),
+                d.getCreatorId(),
+                creator != null ? creator.getName() : null,
+                creator != null ? creator.getProfilePicture() : null,
+                d.getTitle(),
+                d.getDescription(),
+                d.getImageData(),
+                d.getScheduledAt(),
+                d.getCreatedAt(),
+                interestCounts.getOrDefault(d.getDateId(), 0L).intValue(),
+                myInterests.contains(d.getDateId())
+        );
+    }
+
+    private <E extends Enum<E>> List<E> parseEnumList(List<String> values, Class<E> enumClass) {
+        if (values == null || values.isEmpty()) return List.of();
+        return values.stream()
+                .map(s -> {
+                    try { return Enum.valueOf(enumClass, s); }
+                    catch (IllegalArgumentException e) { return null; }
+                })
+                .filter(Objects::nonNull)
+                .toList();
+    }
+}

src/main/java/de/oaa/xxx/dating/DatingDateEntity.java

@@ -0,0 +1,46 @@
+package de.oaa.xxx.dating;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+@Getter
+@Setter
+@Entity
+@Table(name = "dating_date")
+public class DatingDateEntity {
+
+    @Id
+    @Column
+    private UUID dateId;
+
+    @Column(nullable = false)
+    private UUID creatorId;
+
+    @Column(length = 200, nullable = false)
+    private String title;
+
+    @Column(columnDefinition = "MEDIUMTEXT", nullable = false)
+    private String description;
+
+    /** Optional base64-kodiertes Bild */
+    @Column(columnDefinition = "MEDIUMTEXT")
+    private String imageData;
+
+    /** Optionaler Termin – wenn gesetzt, läuft das Date danach ab */
+    @Column
+    private LocalDateTime scheduledAt;
+
+    @Column(nullable = false)
+    private LocalDateTime createdAt;
+
+    /**
+     * Ablaufzeitpunkt: scheduledAt (wenn gesetzt) oder createdAt + 30 Tage.
+     * Wird vom CleanupTask zum Löschen herangezogen.
+     */
+    @Column(nullable = false)
+    private LocalDateTime expiresAt;
+}

src/main/java/de/oaa/xxx/dating/DatingDateInterestEntity.java

@@ -0,0 +1,29 @@
+package de.oaa.xxx.dating;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+@Getter
+@Setter
+@Entity
+@Table(name = "dating_date_interest",
+        uniqueConstraints = @UniqueConstraint(columnNames = {"date_id", "user_id"}))
+public class DatingDateInterestEntity {
+
+    @Id
+    @Column
+    private UUID interestId;
+
+    @Column(name = "date_id", nullable = false)
+    private UUID dateId;
+
+    @Column(name = "user_id", nullable = false)
+    private UUID userId;
+
+    @Column(nullable = false)
+    private LocalDateTime interestedAt;
+}

src/main/java/de/oaa/xxx/dating/DatingDateInterestRepository.java

@@ -0,0 +1,27 @@
+package de.oaa.xxx.dating;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+public interface DatingDateInterestRepository extends JpaRepository<DatingDateInterestEntity, UUID> {
+
+    List<DatingDateInterestEntity> findByDateIdOrderByInterestedAtDesc(UUID dateId);
+
+    Optional<DatingDateInterestEntity> findByDateIdAndUserId(UUID dateId, UUID userId);
+
+    boolean existsByDateIdAndUserId(UUID dateId, UUID userId);
+
+    long countByDateId(UUID dateId);
+
+    @Modifying
+    @Transactional
+    @Query("DELETE FROM DatingDateInterestEntity i WHERE i.dateId = :dateId")
+    void deleteByDateId(@Param("dateId") UUID dateId);
+}

src/main/java/de/oaa/xxx/dating/DatingDateRepository.java

@@ -0,0 +1,22 @@
+package de.oaa.xxx.dating;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.UUID;
+
+public interface DatingDateRepository extends JpaRepository<DatingDateEntity, UUID> {
+
+    List<DatingDateEntity> findByCreatorIdOrderByCreatedAtDesc(UUID creatorId);
+
+    long countByCreatorId(UUID creatorId);
+
+    @Query("SELECT d FROM DatingDateEntity d WHERE d.creatorId != :excludeId AND d.expiresAt > :now ORDER BY d.createdAt DESC")
+    List<DatingDateEntity> findAvailableExcluding(@Param("excludeId") UUID excludeId,
+                                                   @Param("now") LocalDateTime now);
+
+    List<DatingDateEntity> findAllByExpiresAtBefore(LocalDateTime now);
+}

src/main/java/de/oaa/xxx/dating/DatingService.java

@@ -60,11 +60,13 @@ public class DatingService {
             Integer alter,
             double distanzKm,
             String profilePicture,
+            String profilePictureHq,
             String neigung,
             String geschlecht,
             String datingStadt,
             String beschreibung,
-            boolean likedByMe
+            boolean likedByMe,
+            List<UUID> matchingVorliebenIds
     ) {}
 
     record LikeResult(boolean liked, boolean newMatch) {}
@@ -130,10 +132,34 @@ public class DatingService {
                 .map(DatingLikeEntity::getLikedId)
                 .collect(Collectors.toSet());
 
+        // Meine positiven Vorlieben
+        Set<UUID> myPositive = userVorliebeRepository.findByUserId(currentUserId).stream()
+                .filter(uv -> POSITIVE_RATINGS.contains(uv.getBewertung()))
+                .map(UserVorliebeEntity::getItemId)
+                .collect(Collectors.toSet());
+
+        // Positive Vorlieben aller Kandidaten (Batch-Query)
+        Set<UUID> candidateIds = ids.stream().filter(byId::containsKey).collect(Collectors.toSet());
+        Map<UUID, Set<UUID>> candidatePositive = myPositive.isEmpty()
+                ? Map.of()
+                : userVorliebeRepository.findByUserIdIn(candidateIds).stream()
+                        .filter(uv -> POSITIVE_RATINGS.contains(uv.getBewertung()))
+                        .collect(Collectors.groupingBy(
+                                UserVorliebeEntity::getUserId,
+                                Collectors.mapping(UserVorliebeEntity::getItemId, Collectors.toSet())
+                        ));
+
         return ids.stream()
                 .map(byId::get)
                 .filter(Objects::nonNull)
-                .map(u -> toDto(u, currentUserId, likedByMe, myLat, myLon))
+                .map(u -> {
+                    Set<UUID> theirPositive = candidatePositive.getOrDefault(u.getUserId(), Set.of());
+                    List<UUID> matching = myPositive.stream()
+                            .filter(theirPositive::contains)
+                            .limit(5)
+                            .toList();
+                    return toDto(u, currentUserId, likedByMe, myLat, myLon, matching);
+                })
                 .toList();
     }
 
@@ -216,6 +242,17 @@ public class DatingService {
                 .toList();
     }
 
+    public boolean isMatch(UUID userId, UUID otherId) {
+        return matchRepository.existsByUsers(userId, otherId);
+    }
+
+    public void unmatch(UUID userId, UUID otherId) {
+        matchRepository.deleteByUsers(userId, otherId);
+        // Gegenseitige Likes entfernen, damit kein Re-Match beim nächsten Like entsteht
+        likeRepository.deleteByLikerIdAndLikedId(userId, otherId);
+        likeRepository.deleteByLikerIdAndLikedId(otherId, userId);
+    }
+
     public List<UUID> getLikedByMe(UUID userId) {
         return likeRepository.findByLikerId(userId).stream()
                 .map(DatingLikeEntity::getLikedId)
@@ -273,6 +310,39 @@ public class DatingService {
         return ids;
     }
 
+    // ── Filter-Utility für andere Services im Package ─────────────────────────
+
+    /**
+     * Filtert eine Menge von User-IDs nach dem übergebenen DatingFilter.
+     * Verwendet dieselbe Logik wie findSortedIds().
+     * Voraussetzung: Die Kandidaten müssen bereits datingAktiv=true + Koordinaten haben.
+     */
+    Set<UUID> filterUserIds(Collection<UUID> candidateIds, DatingFilter filter,
+                            double myLat, double myLon) {
+        List<UserEntity> candidates = userRepository.findAllById(candidateIds).stream()
+                .filter(u -> u.getDatingLat() != null && u.getDatingLon() != null)
+                .toList();
+
+        candidates = filterByDistance(candidates, myLat, myLon, filter.maxDistanceKm());
+        candidates = filterByAge(candidates, filter.minAge(), filter.maxAge());
+
+        if (!filter.geschlechter().isEmpty()) {
+            candidates = candidates.stream()
+                    .filter(u -> u.getGeschlecht() != null && filter.geschlechter().contains(u.getGeschlecht()))
+                    .toList();
+        }
+        if (!filter.neigungen().isEmpty()) {
+            candidates = candidates.stream()
+                    .filter(u -> u.getNeigung() != null && filter.neigungen().contains(u.getNeigung()))
+                    .toList();
+        }
+        if (!filter.vorliebenIds().isEmpty()) {
+            candidates = filterByVorlieben(candidates, filter.vorliebenIds(), filter.vorliebenUnd());
+        }
+
+        return candidates.stream().map(UserEntity::getUserId).collect(Collectors.toSet());
+    }
+
     // ── Private helpers ───────────────────────────────────────────────────────
 
     private List<UserEntity> filterByDistance(List<UserEntity> users, double myLat, double myLon, int maxKm) {
@@ -316,7 +386,8 @@ public class DatingService {
                 .toList();
     }
 
-    private DatingProfileDto toDto(UserEntity u, UUID currentUserId, Set<UUID> likedByMe, double myLat, double myLon) {
+    private DatingProfileDto toDto(UserEntity u, UUID currentUserId, Set<UUID> likedByMe,
+                                   double myLat, double myLon, List<UUID> matchingVorliebenIds) {
         double dist = Math.round(haversineKm(myLat, myLon, u.getDatingLat(), u.getDatingLon()) * 10.0) / 10.0;
         return new DatingProfileDto(
                 u.getUserId(),
@@ -324,11 +395,13 @@ public class DatingService {
                 u.getAlter(),
                 dist,
                 u.getProfilePicture(),
+                u.getProfilePictureHq(),
                 u.getNeigung() != null ? u.getNeigung().getLabel() : null,
                 u.getGeschlecht() != null ? u.getGeschlecht().getLabel() : null,
                 u.getDatingStadt(),
                 u.getBeschreibung(),
-                likedByMe.contains(u.getUserId())
+                likedByMe.contains(u.getUserId()),
+                matchingVorliebenIds
         );
     }
 

src/main/java/de/oaa/xxx/social/SystemMessageService.java

@@ -57,8 +57,9 @@ public class SystemMessageService {
                 .findByUserIdAndCause(receiverId, cause)
                 .orElseGet(() -> NotificationPreferenceEntity.defaultFor(receiverId, cause));
 
-        // FRIENDREQUEST und INVITATION sind immer nur in-app, kein E-Mail
-        boolean sendInApp = cause == MessageCause.FRIENDREQUEST || cause == MessageCause.INVITATION || pref.isInApp();
+        // FRIENDREQUEST, INVITATION und DATE_INTEREST sind immer nur in-app, kein E-Mail
+        boolean sendInApp = cause == MessageCause.FRIENDREQUEST || cause == MessageCause.INVITATION
+                || cause == MessageCause.DATE_INTEREST || pref.isInApp();
 
         if (sendInApp) {
             MessageEntity msg = new MessageEntity();
@@ -76,7 +77,7 @@ public class SystemMessageService {
             sseService.push(receiverId, "NOTIFICATION", Map.of("unreadCount", unread, "text", text));
         }
 
-        if (pref.isEmail() && cause != MessageCause.INVITATION) {
+        if (pref.isEmail() && cause != MessageCause.INVITATION && cause != MessageCause.DATE_INTEREST) {
             userRepository.findById(receiverId).ifPresent(user -> {
                 try {
                     Email email = new Email();
@@ -107,6 +108,7 @@ public class SystemMessageService {
             case EMERGENCY     -> "XXX The Game – ⚠️ Notfall";
             case FRIENDREQUEST -> "XXX The Game – Neue Freundschaftsanfrage";
             case SUPPORT       -> "xXx Sphere – Nachricht vom Support";
+            case DATE_INTEREST -> "xXx Sphere – Interesse an deinem Date";
         };
     }
 

src/main/java/de/oaa/xxx/social/entity/MessageCause.java

@@ -5,5 +5,6 @@ public enum MessageCause {
     GAME_STATE,
     EMERGENCY,
     FRIENDREQUEST,
-    SUPPORT
+    SUPPORT,
+    DATE_INTEREST
 }

src/main/java/de/oaa/xxx/user/UserController.java

@@ -12,6 +12,7 @@ import java.util.stream.Collectors;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseCookie;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.DeleteMapping;
@@ -94,6 +95,8 @@ public class UserController {
     record DatingRequest(boolean datingAktiv, String datingStadt, Double datingLat, Double datingLon,
                          List<String> datingGeschlechter,
                          Integer datingMaxDistanzKm, Integer datingMinAlter, Integer datingMaxAlter) {}
+    record DatingFilterRequest(List<String> datingGeschlechter,
+                               Integer datingMaxDistanzKm, Integer datingMinAlter, Integer datingMaxAlter) {}
     record PrivacyRequest(
             Sichtbarkeit sichtbarkeitGrunddaten,
             Sichtbarkeit sichtbarkeitGalerie,
@@ -112,22 +115,51 @@ public class UserController {
         }
         var user = userService.requireUser(principal);
         user.setDatingAktiv(request.datingAktiv());
-        user.setDatingStadt(request.datingAktiv() ? request.datingStadt().trim() : null);
-        user.setDatingLat(request.datingAktiv() ? request.datingLat() : null);
-        user.setDatingLon(request.datingAktiv() ? request.datingLon() : null);
-        if (request.datingGeschlechter() != null && !request.datingGeschlechter().isEmpty()) {
+        if (!request.datingAktiv()) {
+            // Alle Dating-Einstellungen zurücksetzen
+            user.setDatingStadt(null);
+            user.setDatingLat(null);
+            user.setDatingLon(null);
+            user.setDatingGeschlechter(null);
+            user.setDatingMaxDistanzKm(null);
+            user.setDatingMinAlter(null);
+            user.setDatingMaxAlter(null);
+        } else {
+            user.setDatingStadt(request.datingStadt().trim());
+            user.setDatingLat(request.datingLat());
+            user.setDatingLon(request.datingLon());
+            if (request.datingGeschlechter() != null && !request.datingGeschlechter().isEmpty()) {
+                String joined = request.datingGeschlechter().stream()
+                        .filter(g -> { try { Geschlecht.valueOf(g); return true; } catch (IllegalArgumentException e) { return false; } })
+                        .collect(Collectors.joining(","));
+                user.setDatingGeschlechter(joined.isBlank() ? null : joined);
+            } else {
+                user.setDatingGeschlechter(null);
+            }
+            if (request.datingMaxDistanzKm() != null) user.setDatingMaxDistanzKm(Math.max(1, Math.min(500, request.datingMaxDistanzKm())));
+            if (request.datingMinAlter() != null) user.setDatingMinAlter(Math.max(18, Math.min(99, request.datingMinAlter())));
+            if (request.datingMaxAlter() != null) user.setDatingMaxAlter(Math.max(18, Math.min(99, request.datingMaxAlter())));
+        }
+        userRepository.save(user);
+        LOGGER.info("User {} hat Dating-Einstellungen aktualisiert: aktiv={}", user.getUserId(), request.datingAktiv());
+        return ResponseEntity.ok().build();
+    }
+
+    @PutMapping("/me/dating-filter")
+    public ResponseEntity<Void> updateDatingFilter(@RequestBody DatingFilterRequest request, Principal principal) {
+        var user = userService.requireUser(principal);
+        if (!user.isDatingAktiv())
+            return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
+        if (request.datingGeschlechter() != null) {
             String joined = request.datingGeschlechter().stream()
                     .filter(g -> { try { Geschlecht.valueOf(g); return true; } catch (IllegalArgumentException e) { return false; } })
                     .collect(Collectors.joining(","));
             user.setDatingGeschlechter(joined.isBlank() ? null : joined);
-        } else {
-            user.setDatingGeschlechter(null);
         }
         if (request.datingMaxDistanzKm() != null) user.setDatingMaxDistanzKm(Math.max(1, Math.min(500, request.datingMaxDistanzKm())));
-        if (request.datingMinAlter() != null) user.setDatingMinAlter(Math.max(18, Math.min(99, request.datingMinAlter())));
-        if (request.datingMaxAlter() != null) user.setDatingMaxAlter(Math.max(18, Math.min(99, request.datingMaxAlter())));
+        if (request.datingMinAlter()     != null) user.setDatingMinAlter(Math.max(18, Math.min(99, request.datingMinAlter())));
+        if (request.datingMaxAlter()     != null) user.setDatingMaxAlter(Math.max(18, Math.min(99, request.datingMaxAlter())));
         userRepository.save(user);
-        LOGGER.info("User {} hat Dating-Einstellungen aktualisiert: aktiv={}", user.getUserId(), request.datingAktiv());
         return ResponseEntity.ok().build();
     }
 

src/main/java/de/oaa/xxx/user/UserEntity.java

@@ -1,15 +1,19 @@
 package de.oaa.xxx.user;
 
-import jakarta.persistence.*;
-import lombok.Getter;
-import lombok.Setter;
-
 import java.time.LocalDate;
 import java.time.Period;
 import java.util.Arrays;
-import java.util.List;
 import java.util.UUID;
 
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.Getter;
+import lombok.Setter;
+
 @Getter
 @Setter
 @Entity