feat: add personal dashboard

server/src/main/java/de/tum/cit/memo/controller/ContributorStatsController.java

@@ -0,0 +1,29 @@
+package de.tum.cit.memo.controller;
+
+import de.tum.cit.memo.dto.ContributorStatsResponse;
+import de.tum.cit.memo.service.ContributorStatsService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/api/users")
+@RequiredArgsConstructor
+@Tag(name = "Contributor Stats", description = "Endpoints for contributor statistics and gamification")
+public class ContributorStatsController {
+
+    private final ContributorStatsService contributorStatsService;
+
+    @GetMapping("/{userId}/stats")
+    @Operation(summary = "Get contributor statistics", description = "Returns contribution stats including total votes, streaks, daily counts for heatmap, "
+            + "and earned badge IDs.")
+    public ResponseEntity<ContributorStatsResponse> getContributorStats(@PathVariable String userId) {
+        ContributorStatsResponse stats = contributorStatsService.getStats(userId);
+        return ResponseEntity.ok(stats);
+    }
+}

server/src/main/java/de/tum/cit/memo/controller/SchedulingController.java

@@ -34,7 +34,7 @@ public ResponseEntity<RelationshipTaskResponse> getNextRelationship(
     }
 
     @PostMapping("/vote")
-    @Operation(summary = "Submit a vote on a relationship", description = "Records the user's vote on a competency pair identified by originId + destinationId.")
+    @Operation(summary = "Submit a vote on a relationship", description = "Records the user's vote on a competency relationship. Requires originId and destinationId pair. MATCHES and UNRELATED votes are bidirectional.")
     public ResponseEntity<VoteResponse> submitVote(
             @RequestHeader("X-User-Id") String userId,
             @Valid @RequestBody VoteRequest request) {

server/src/main/java/de/tum/cit/memo/dto/ContributorStatsResponse.java

@@ -0,0 +1,31 @@
+package de.tum.cit.memo.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDate;
+import java.util.List;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ContributorStatsResponse {
+
+    private int totalVotes;
+    private int currentStreak;
+    private int longestStreak;
+    private List<DailyCount> dailyCounts;
+    private List<String> earnedBadges;
+
+    @Data
+    @Builder
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class DailyCount {
+        private LocalDate date;
+        private int count;
+    }
+}

server/src/main/java/de/tum/cit/memo/dto/VoteRequest.java

@@ -1,6 +1,8 @@
 package de.tum.cit.memo.dto;
 
+import io.swagger.v3.oas.annotations.media.Schema;
 import de.tum.cit.memo.enums.RelationshipType;
+import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -13,12 +15,20 @@
 @AllArgsConstructor
 public class VoteRequest {
 
-    @NotNull
+    /**
+     * Origin competency ID.
+     */
+    @NotBlank(message = "originId is required")
+    @Schema(description = "Origin competency ID", requiredMode = Schema.RequiredMode.REQUIRED)
     private String originId;
 
-    @NotNull
+    /**
+     * Destination competency ID.
+     */
+    @NotBlank(message = "destinationId is required")
+    @Schema(description = "Destination competency ID", requiredMode = Schema.RequiredMode.REQUIRED)
     private String destinationId;
 
-    @NotNull
+    @NotNull(message = "Relationship type is required")
     private RelationshipType relationshipType;
 }

server/src/main/java/de/tum/cit/memo/entity/CompetencyRelationship.java

@@ -93,7 +93,7 @@ public void recalculateEntropy() {
         }
 
         double ent = 0.0;
-        int[] counts = { voteAssumes, voteExtends, voteMatches, voteUnrelated };
+        int[] counts = {voteAssumes, voteExtends, voteMatches, voteUnrelated};
         for (int count : counts) {
             if (count > 0) {
                 double p = (double) count / total;

server/src/main/java/de/tum/cit/memo/repository/CompetencyRelationshipVoteRepository.java

@@ -2,10 +2,24 @@
 
 import de.tum.cit.memo.entity.CompetencyRelationshipVote;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
 
+import java.time.Instant;
+import java.util.List;
+
 @Repository
 public interface CompetencyRelationshipVoteRepository extends JpaRepository<CompetencyRelationshipVote, String> {
 
     boolean existsByRelationshipIdAndUserId(String relationshipId, String userId);
+
+    long countByUserId(String userId);
+
+    @Query(value = "SELECT CAST(v.created_at AS DATE) AS vote_date, COUNT(*) AS vote_count "
+            + "FROM competency_relationships_votes v "
+            + "WHERE v.user_id = :userId AND v.created_at >= :since "
+            + "GROUP BY CAST(v.created_at AS DATE) "
+            + "ORDER BY vote_date", nativeQuery = true)
+    List<Object[]> findDailyVoteCountsByUserId(@Param("userId") String userId, @Param("since") Instant since);
 }

server/src/main/java/de/tum/cit/memo/service/CompetencyRelationshipService.java

@@ -61,8 +61,9 @@ private CompetencyRelationship buildAndSave(String originId, String destinationI
                 .destinationId(destinationId)
                 .build();
 
+        CompetencyRelationship saved = relationshipRepository.save(relationship);
         competencyRepository.incrementDegree(List.of(originId, destinationId));
-        return relationshipRepository.save(relationship);
+        return saved;
     }
 
     private static void validateDistinctIds(String originId, String destinationId) {

server/src/main/java/de/tum/cit/memo/service/ContributorStatsService.java

@@ -0,0 +1,140 @@
+package de.tum.cit.memo.service;
+
+import de.tum.cit.memo.dto.ContributorStatsResponse;
+import de.tum.cit.memo.dto.ContributorStatsResponse.DailyCount;
+import de.tum.cit.memo.repository.CompetencyRelationshipVoteRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.ZoneOffset;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Computes contributor statistics on-the-fly from vote timestamps.
+ * All date calculations use UTC.
+ */
+@Service
+@RequiredArgsConstructor
+public class ContributorStatsService {
+
+    private final CompetencyRelationshipVoteRepository voteRepository;
+
+    @Transactional(readOnly = true)
+    public ContributorStatsResponse getStats(String userId) {
+        LocalDate today = LocalDate.now(ZoneOffset.UTC);
+        LocalDate since = today.minusDays(365);
+        Instant sinceInstant = since.atStartOfDay(ZoneOffset.UTC).toInstant();
+
+        // Fetch raw daily counts from votes
+        List<Object[]> rawCounts = voteRepository.findDailyVoteCountsByUserId(userId, sinceInstant);
+
+        // Build ordered map of date -> count
+        Map<LocalDate, Integer> countMap = new LinkedHashMap<>();
+        int totalVotes = 0;
+        for (Object[] row : rawCounts) {
+            LocalDate date = ((java.sql.Date) row[0]).toLocalDate();
+            int count = ((Number) row[1]).intValue();
+            countMap.put(date, count);
+            totalVotes += count;
+        }
+
+        // Also count votes before the 365-day window
+        long olderVotes = voteRepository.countByUserId(userId) - totalVotes;
+        totalVotes += (int) Math.max(olderVotes, 0);
+
+        // Build daily counts list for heatmap
+        List<DailyCount> dailyCounts = new ArrayList<>();
+        for (Map.Entry<LocalDate, Integer> entry : countMap.entrySet()) {
+            dailyCounts.add(DailyCount.builder()
+                    .date(entry.getKey())
+                    .count(entry.getValue())
+                    .build());
+        }
+
+        // Calculate streaks
+        int currentStreak = calculateCurrentStreak(countMap, today);
+        int longestStreak = calculateLongestStreak(countMap, since, today);
+
+        // Evaluate badges
+        List<String> earnedBadges = evaluateBadges(totalVotes, currentStreak, longestStreak);
+
+        return ContributorStatsResponse.builder()
+                .totalVotes(totalVotes)
+                .currentStreak(currentStreak)
+                .longestStreak(longestStreak)
+                .dailyCounts(dailyCounts)
+                .earnedBadges(earnedBadges)
+                .build();
+    }
+
+    /**
+     * Current streak: count consecutive days ending at today (or yesterday).
+     */
+    private int calculateCurrentStreak(Map<LocalDate, Integer> countMap, LocalDate today) {
+        // Check if the user contributed today; if not, start from yesterday
+        LocalDate checkDate = countMap.containsKey(today) ? today : today.minusDays(1);
+        int streak = 0;
+        while (countMap.containsKey(checkDate) && countMap.get(checkDate) > 0) {
+            streak++;
+            checkDate = checkDate.minusDays(1);
+        }
+        return streak;
+    }
+
+    /**
+     * Longest streak within the daily counts window.
+     */
+    private int calculateLongestStreak(Map<LocalDate, Integer> countMap, LocalDate since, LocalDate today) {
+        int longest = 0;
+        int current = 0;
+        LocalDate d = since;
+        while (!d.isAfter(today)) {
+            if (countMap.containsKey(d) && countMap.get(d) > 0) {
+                current++;
+                longest = Math.max(longest, current);
+            } else {
+                current = 0;
+            }
+            d = d.plusDays(1);
+        }
+        return longest;
+    }
+
+    /**
+     * Evaluate which badges the user has earned.
+     */
+    private List<String> evaluateBadges(int totalVotes, int currentStreak, int longestStreak) {
+        List<String> badges = new ArrayList<>();
+        int maxStreak = Math.max(currentStreak, longestStreak);
+
+        if (totalVotes >= 1) {
+            badges.add("first-steps");
+        }
+        if (totalVotes >= 10) {
+            badges.add("getting-started");
+        }
+        if (totalVotes >= 50) {
+            badges.add("half-century");
+        }
+        if (totalVotes >= 100) {
+            badges.add("century");
+        }
+        if (maxStreak >= 3) {
+            badges.add("streak-3");
+        }
+        if (maxStreak >= 7) {
+            badges.add("streak-7");
+        }
+        if (maxStreak >= 30) {
+            badges.add("streak-30");
+        }
+
+        return badges;
+    }
+}