running = contestMapper.findByStatus(ContestStatus.RUNNING.name());
+ for (Contest contest : running) {
+ if (contest.getEndTime() != null && !contest.getEndTime().isAfter(LocalDateTime.now())) {
+ transitionToFinished(contest);
+ }
+ }
+ }
+
+ @Transactional
+ void transitionToRunning(Contest contest) { ... }
+
+ @Transactional
+ void transitionToFinished(Contest contest) { ... }
+}
+```
+
+### Pattern 2: Codeforces Rating Calculation
+**What:** CF Elo variant with K-factor based on contest count, expected score = 1 / (1 + 10^((opponentRating - myRating) / 400)).
+**When to use:** After contest ends, for all STARTED participants.
+**Source:** [CITED: codeforces.com/blog/entry/102] -- CF rating system documentation
+
+```java
+public record RatingResult(String oderId, int oldRating, int newRating, int change) {
+
+ /**
+ * Calculate new rating using Codeforces Elo variant.
+ *
+ * Expected score = 1 / (1 + 10^((opponentRating - myRating) / 400))
+ * Rating change = round(K * (actualScore - expectedScore))
+ * K = 32 for new players, decreases with more contests
+ */
+ public static RatingResult calculate(int myRating, int opponentRating, boolean won) {
+ double expected = 1.0 / (1.0 + Math.pow(10, (opponentRating - myRating) / 400.0));
+ double actual = won ? 1.0 : 0.0;
+ int k = determineKFactor(myRating);
+ int change = (int) Math.round(k * (actual - expected));
+ return new RatingResult(myRating + change, change);
+ }
+
+ static int determineKFactor(int rating) {
+ if (rating < 2100) return 32;
+ if (rating < 2400) return 24;
+ return 16;
+ }
+}
+```
+
+### Anti-Patterns to Avoid
+
+- **Timezone mismatch:** Always use `LocalDateTime.now()` vs `Instant.now()` -- check which the DB stores and be consistent. DB `start_time` is `datetime(3)` without zone; Java uses system default. Document this clearly.
+- **Double transition:** If scheduler polls at t=0 and t=10s, and transition takes 5s, second poll may re-trigger. D-04 (idempotent) prevents this, but the implementation must re-check status before writing.
+- **Rating for unregistered participants:** D-11 requires global_ranking record to exist. Users who never attended a rated contest should not get a rating. The system must create the record at rating=1500 if missing.
+- **Concurrent rating updates:** If contest ends and admin manually triggers a re-rating, both could write simultaneously. Use `@Transactional` with appropriate isolation level.
+
+## Common Pitfalls
+
+### Pitfall 1: Null end_time causing contests to never finish
+**What goes wrong:** Some contests in the DB have `end_time = NULL` (visible in seed data). The scheduler condition `if (now >= end_time)` will never trigger for these.
+**Why it happens:** The `contests.end_time` column is nullable in the schema. The `end_time` is computed as `start_time + duration_minutes` but may not always be stored.
+**How to avoid:** Compute effective end time as `contest.getStartTime().plusMinutes(contest.getDurationMinutes())` when `end_time` is null. Alternatively, the scheduler should always compute end_time from start_time + duration when the DB column is null.
+**Warning signs:** Contests stuck in RUNNING status after duration expires.
+
+### Pitfall 2: Rating title mismatch between enum and rating thresholds
+**What goes wrong:** RatingTitle enum values (e.g., `CANDIDATE_MASTER`) don't match the D-08 thresholds exactly.
+**Why it happens:** The enum was defined independently from the rating boundary decisions.
+**How to avoid:** Define a static method in `RatingTitle` that maps rating integer to enum value. Never rely on enum ordinal or name matching the threshold. Use a lookup table instead.
+**Warning signs:** Users showing `CANDIDATE_MASTER` at 2000 rating instead of 2100+.
+
+### Pitfall 3: Judge verdict push missing contestId in payload
+**What goes wrong:** `JudgeWorkerProcessor.pushResult()` creates `SubmissionResultPayload.of(submissionId, null, problemId, ...)` with null contestId. The frontend contest page needs contestId to correlate the result.
+**Why it happens:** Phase 12 built the method without contest context.
+**How to avoid:** Modify `JudgeJob` to carry contestId. When verdict is written, check if submission is part of an active contest (via ContestSubmission record) and include it in the WebSocket payload. Fall back to null for non-contest submissions.
+**Warning signs:** Frontend receives verdict but can't update contest ranking board.
+
+### Pitfall 4: Infinite flush loop on contest finish
+**What goes wrong:** After contest ends, the scheduler marks it dirty one final time and `flushPendingRankings()` emits a last ranking update. If `markDirty` is called from multiple places (submission + scheduler), it may flush multiple times unnecessarily.
+**Why it happens:** The pendingRankingUpdates map tracks dirty contests but does not distinguish "during contest" vs "final update after contest".
+**How to avoid:** Skip `markDirty` for FINISHED contests in the submission callback. The scheduler's transitionToFinished() should directly emit the final ranking (not go through the throttle path), then not add to pendingUpdates.
+
+## Code Examples
+
+### Flushing pending ranking updates (existing RealtimeService pattern)
+**Source:** `backend-spring/src/main/java/com/ulticode/modules/websocket/service/RealtimeService.java`
+
+```java
+@Scheduled(fixedRate = 1000) // 1 second flush
+public void flushPendingRankings() {
+ Set dirty = Set.copyOf(pendingRankingUpdates.keySet());
+ pendingRankingUpdates.clear();
+
+ for (String contestId : dirty) {
+ Long lastPush = lastRankingPushTime.get(contestId);
+ long elapsed = System.currentTimeMillis() - lastPush;
+
+ if (elapsed >= RANKING_THROTTLE_MS) {
+ List rankings = rankingService.getLiveRanking(contestId, 200);
+ emitRankingUpdate(contestId, rankings);
+ lastRankingPushTime.put(contestId, System.currentTimeMillis());
+ } else {
+ // Re-mark as dirty for next flush
+ pendingRankingUpdates.putIfAbsent(contestId, true);
+ }
+ }
+}
+
+public void markDirty(String contestId) {
+ pendingRankingUpdates.putIfAbsent(contestId, true);
+}
+```
+
+### Mapping rating to title
+**Source:** [CITED: codeforces.com/blog/entry/102]
+
+```java
+public static RatingTitle fromRating(int rating) {
+ if (rating < 1200) return RatingTitle.NEWBIE;
+ if (rating < 1400) return RatingTitle.PUPIL;
+ if (rating < 1600) return RatingTitle.SPECIALIST;
+ if (rating < 1900) return RatingTitle.EXPERT;
+ if (rating < 2100) return RatingTitle.CANDIDATE_MASTER;
+ if (rating < 2300) return RatingTitle.MASTER;
+ if (rating < 2400) return RatingTitle.INTERNATIONAL_MASTER;
+ if (rating < 2600) return RatingTitle.GRANDMASTER;
+ if (rating < 3000) return RatingTitle.INTERNATIONAL_GRANDMASTER;
+ return RatingTitle.LEGENDARY_GRANDMASTER;
+}
+```
+
+### Transitioning participant status on contest start
+The scheduler should NOT directly change participant status from REGISTERED to STARTED. Instead, the first submission by a registered participant sets their status to STARTED (handled in Phase 13's SubmissionService). The scheduler only transitions the contest's own status field.
+
+However, after RUNNING→FINISHED, the scheduler should transition all STARTED participants to FINISHED:
+
+```java
+@Transactional
+public void finishContest(String contestId) {
+ // Update contest status
+ Contest contest = contestMapper.selectById(contestId);
+ contest.setStatus(ContestStatus.FINISHED.name());
+ contest.setActualEndTime(LocalDateTime.now());
+ contestMapper.updateById(contest);
+
+ // Transition all STARTED participants to FINISHED
+ List active = participantMapper.findByContestIdAndStatus(
+ contestId, ContestParticipantStatus.STARTED.name());
+ for (ContestParticipant p : active) {
+ p.setStatus(ContestParticipantStatus.FINISHED.name());
+ p.setFinishedAt(LocalDateTime.now());
+ participantMapper.updateById(p);
+ }
+
+ // Calculate ratings
+ ratingCalculationService.calculateAndUpdate(contestId);
+}
+```
+
+## State of the Art
+
+| Old Approach | Current Approach | When Changed | Impact |
+|--------------|------------------|--------------|--------|
+| Manual contest lifecycle | @Scheduled polling (10s) | Phase 14 | Contests auto-start/stop without admin |
+| No rating system | CF Elo variant | Phase 14 | Participants earn persistent ratings |
+| Polling-based ranking | WebSocket push (throttled 1s) | Phase 14 | Real-time leaderboard, reduced server load |
+| Poll for verdict | WebSocket push on verdict | Phase 14 (JUDGE-04) | Instant browser notification |
+
+**Deprecated/outdated:**
+- Direct WebSocket endpoint push (without throttle): replaced by flush-based batching to prevent spam
+- Rating without volatility: current CF system uses K-factor only, no volatility parameter (simpler)
+
+## Assumptions Log
+
+| # | Claim | Section | Risk if Wrong |
+|---|-------|---------|---------------|
+| A1 | `contests.end_time` may be NULL; effective end time = start_time + duration_minutes | Common Pitfalls | Contests could get stuck RUNNING if end_time is null |
+| A2 | Participant status REGISTERED→STARTED is triggered by first submission, not by scheduler | Architecture | If Phase 13 didn't implement this, participants will show as REGISTERED even after contest starts |
+| A3 | CF K-factor thresholds: <2100 = 32, <2400 = 24, >=2400 = 16 | Rating Engine | Standard CF values, but D-08 didn't specify -- flag for confirmation |
+| A4 | Rating only for participants with global_ranking record (D-11) means skip users without one | Rating Engine | If a STARTED participant has no global_ranking record, they are skipped -- correct per D-11 |
+| A5 | `markDirty` from submission callback and `flushPendingRankings` are the only ranking update paths | Architecture | If other code paths bypass the throttle, flooding is possible |
+
+## Open Questions
+
+1. **K-factor thresholds for rating calculation**
+ - What we know: CF standard uses 32 (<2100), 24 (<2400), 16 (>=2400)
+ - What's unclear: D-08 didn't specify K-factor values -- only title thresholds
+ - Recommendation: Use standard CF K-factor values; if user wants different, they can override via `contest_scoring_rules`
+
+2. **Should the scheduler also transition REGISTERED participants to STARTED?**
+ - What we know: D-06 mentions STARTED participants for rating calculation, but no explicit decision on who sets this status
+ - What's unclear: Phase 13's SubmissionService may have implemented participant STARTED transition on first submit -- verify before planning
+ - Recommendation: Check Phase 13 implementation; if not done, scheduler should do it during UPCOMING→RUNNING
+
+3. **SCORE vs ICPC scoring mode impact on ranking**
+ - What we know: `contests.scoring_mode` can be SCORE or ICPC
+ - What's unclear: Does ranking sort by totalScore (SCORE) or solved_count+penalty (ICPC)?
+ - Recommendation: RankingService.getLiveRanking() should respect scoring_mode: ICPC = sort by solved_count DESC, penalty ASC; SCORE = sort by totalScore DESC, penalty ASC
+
+4. **Global rank recalculation after batch rating update**
+ - What we know: After updating all global_rankings.rating, the global_rank column needs to be recomputed (rank = 1, 2, 3... by rating DESC)
+ - What's unclear: Should this be done in the same transaction or as a separate batch?
+ - Recommendation: Separate batch update after rating calculation completes; use a single UPDATE with row_number or fetch-then-update approach
+
+## Environment Availability
+
+Step 2.6: SKIPPED (no external dependencies -- all required tools (Java 17, Maven, MySQL, Redis) are already available from project setup).
+
+## Sources
+
+### Primary (HIGH confidence)
+- `backend-spring/src/main/java/com/ulticode/UlticodeBackendApplication.java` -- @EnableScheduling confirmed
+- `backend-spring/src/main/java/com/ulticode/modules/backup/scheduler/BackupScheduler.java` -- @Scheduled pattern reference
+- `backend-spring/src/main/java/com/ulticode/modules/websocket/service/RealtimeService.java` -- Throttle infrastructure, emitRankingUpdate, emitSubmissionResult
+- `backend-spring/src/main/java/com/ulticode/modules/websocket/constants/WebSocketConstants.java` -- USER_QUEUE_SUBMISSION constant
+- `backend-spring/src/main/java/com/ulticode/modules/websocket/util/WebSocketUtils.java` -- getContestRoomName returns /topic/contest/{id}
+- `backend-spring/src/main/java/com/ulticode/modules/websocket/contest/dto/RankingUpdatePayload.java` -- RankingItem record with rank, userId, username, score, solvedCount, penalty
+- `backend-spring/src/main/java/com/ulticode/modules/websocket/contest/dto/SubmissionResultPayload.java` -- SubmissionResultPayload record
+- `backend-spring/src/main/java/com/ulticode/modules/websocket/event/ContestStatusEvent.java` -- ContestStatus enum (UPCOMING, REGISTRATION, RUNNING, ENDED)
+- `backend-spring/src/main/java/com/ulticode/modules/queue/processor/JudgeWorkerProcessor.java` -- pushResult() calls realtimeService.emitSubmissionResult(); line 291-296
+- `backend-spring/src/main/java/com/ulticode/modules/contest/mapper/ContestMapper.java` -- findByStatus() method already exists
+- `backend-spring/src/main/java/com/ulticode/modules/contest/mapper/ContestParticipantMapper.java` -- findByContestIdAndStatus() with status filter
+- `backend-spring/src/main/java/com/ulticode/modules/contest/entity/GlobalRanking.java` -- rating, maxRating, ratingTitle, maxRatingTitle fields
+- `backend-spring/src/main/java/com/ulticode/modules/contest/entity/Contest.java` -- startTime, endTime, durationMinutes, status, actualStartTime, actualEndTime
+- `backend-spring/src/main/java/com/ulticode/modules/contest/entity/ContestParticipant.java` -- finalRank, totalPenalty, totalScore, totalAttempts, status
+- `backend-spring/src/main/java/com/ulticode/modules/contest/entity/enums/RatingTitle.java` -- 10 title levels
+- `backend-spring/src/main/java/com/ulticode/modules/contest/entity/enums/ContestParticipantStatus.java` -- REGISTERED, STARTED, FINISHED, DISQUALIFIED
+- `backend-spring/src/main/java/com/ulticode/modules/contest/service/impl/RankingServiceImpl.java` -- getLiveRanking() with score/penalty sort
+- `db-manager/migrations/V3__contest_schema.sql` -- contests.end_time nullable, contest_participants.status, scoring_mode
+
+### Secondary (MEDIUM confidence)
+- [codeforces.com/blog/entry/102] -- CF rating formula (K-factor, expected score, rating change)
+- [Assumed] K-factor values: <2100 = 32, <2400 = 24, >=2400 = 16 -- standard CF values not verified against project documentation
+
+## Metadata
+
+**Confidence breakdown:**
+- Standard stack: HIGH -- all infrastructure exists, @Scheduled already enabled
+- Architecture: HIGH -- patterns confirmed from existing code
+- Pitfalls: MEDIUM -- null end_time and judge verdict push are based on code inspection but haven't been validated by running the system
+
+**Research date:** 2026-04-19
+**Valid until:** 2026-05-19 (30 days -- contest system patterns are stable)
diff --git a/.planning/phases/14-contest-engine/14-REVIEW.md b/.planning/phases/14-contest-engine/14-REVIEW.md
new file mode 100644
index 000000000..e022986e2
--- /dev/null
+++ b/.planning/phases/14-contest-engine/14-REVIEW.md
@@ -0,0 +1,258 @@
+---
+phase: 14
+reviewed: 2026-04-19T08:59:00Z
+depth: standard
+files_reviewed: 7
+files_reviewed_list:
+ - backend-spring/src/main/java/com/ulticode/modules/contest/scheduler/ContestScheduler.java
+ - backend-spring/src/main/java/com/ulticode/modules/contest/service/RatingCalculationService.java
+ - backend-spring/src/main/java/com/ulticode/modules/contest/service/impl/RatingCalculationServiceImpl.java
+ - backend-spring/src/main/java/com/ulticode/modules/websocket/service/RealtimeService.java
+ - backend-spring/src/main/java/com/ulticode/modules/queue/processor/JudgeWorkerProcessor.java
+ - backend-spring/src/main/java/com/ulticode/modules/submission/service/impl/SubmissionServiceImpl.java
+ - backend-spring/src/main/java/com/ulticode/modules/contest/entity/Contest.java
+findings:
+ critical: 1
+ warning: 3
+ info: 2
+ total: 6
+status: issues_found
+---
+
+# Phase 14: Code Review Report
+
+**Reviewed:** 2026-04-19
+**Depth:** standard
+**Files Reviewed:** 7
+**Status:** issues_found
+
+## Summary
+
+Phase 14 implements a contest engine with scheduling, real-time WebSocket updates, CF-style Elo rating, and judge queue integration. One critical bug was found in the rating calculation formula -- it does not reflect actual Codeforces Elo behavior. Several thread-safety and race condition issues were also identified.
+
+---
+
+## Critical Issues
+
+### CR-01: Incorrect Codeforces Elo Rating Formula
+
+**File:** `backend-spring/src/main/java/com/ulticode/modules/contest/service/impl/RatingCalculationServiceImpl.java:94-115`
+
+**Issue:** The `calculateNewRating` method treats every participant's result as a perfect score (actual=1.0), then derives rating change from `k * (1 - avgExpected)`. This is fundamentally wrong.
+
+Codeforces Elo works by comparing each participant against every other participant individually using their actual contest ranks, not an aggregate "did you win" boolean.
+
+Current (incorrect) algorithm:
+```java
+double avgExpected = totalExpected / (participantCount - 1);
+int change = (int) Math.round(k * (1.0 - avgExpected)); // Always assumes actual=1 (win)
+```
+
+This means:
+- A user who places LAST (0 wins) gets the same rating gain formula as someone who places FIRST
+- The actual rank placement is completely ignored
+- Only the number of opponents and their ratings matter
+
+**Fix:**
+
+The correct CF rating change for participant `i` is:
+```
+actual_i = (n - rank_i + 1) / n // where n = number of participants, rank starts at 1
+expected_i = sum over j != i of 1/(1 + 10^((r_j - r_i)/400)) / (n-1)
+change_i = k * (actual_i - expected_i)
+```
+
+Or if you want to use the pairwise CF approach, for each pair:
+```java
+// For each participant pair (i vs j):
+// If rank_i < rank_j: actual_i beats actual_j (1.0 vs 0.0)
+// expected = 1 / (1 + 10^((r_j - r_i)/400))
+// change += k * (actual - expected)
+```
+
+**Recommended fix in `calculateNewRating`:**
+```java
+private int calculateNewRating(int myRating, List allParticipants,
+ ContestParticipant me, int myRank) {
+ double totalExpected = 0.0;
+
+ for (ContestParticipant opponent : allParticipants) {
+ if (opponent.getUserId().equals(me.getUserId())) continue;
+
+ Optional oppGr = globalRankingMapper.findByUserId(opponent.getUserId());
+ if (oppGr.isEmpty()) continue;
+
+ int oppRating = oppGr.get().getRating() != null ? oppGr.get().getRating() : 1500;
+ double expected = 1.0 / (1.0 + Math.pow(10, (oppRating - myRating) / 400.0));
+ totalExpected += expected;
+ }
+
+ int participantCount = allParticipants.size();
+ double avgExpected = participantCount > 1 ? totalExpected / (participantCount - 1) : 0.5;
+
+ // CF uses actual score based on rank: (n - rank + 1) / n
+ double actual = (double) (participantCount - myRank + 1) / participantCount;
+
+ int k = determineKFactor(myRating);
+ int change = (int) Math.round(k * (actual - avgExpected));
+ return Math.max(0, Math.min(3500, myRating + change));
+}
+```
+
+Note: The method signature must change to accept `myRank` from the caller, which has it available from the sort order at line 41-49.
+
+---
+
+## Warnings
+
+### WR-01: Race Condition in Contest Scheduler Transitions
+
+**File:** `backend-spring/src/main/java/com/ulticode/modules/contest/scheduler/ContestScheduler.java:63-109`
+
+**Issue:** The idempotency check in `transitionToRunning` and `transitionToFinished` reads the current status, but between the check and `updateById`, another thread could change the status. The DB update then silently overwrites that change without detecting the conflict.
+
+```java
+void transitionToRunning(Contest contest) {
+ // Re-check: skip if already RUNNING (idempotent)
+ if (RUNNING.name().equals(contest.getStatus())) { // <-- TOCTOU: status could change here
+ return;
+ }
+ contest.setStatus(RUNNING.name());
+ contestMapper.updateById(contest); // <-- Could overwrite a later transition to FINISHED
+}
+```
+
+**Fix:** Use optimistic locking via a `version` field with `@Version` annotation, or use a conditional update:
+```java
+int updated = contestMapper.updateStatusIfCurrent(contest.getId(), "UPCOMING", "RUNNING");
+if (updated == 0) {
+ log.warn("Contest {} status transition race detected", contest.getId());
+}
+```
+
+### WR-02: Throttle Flush Can Drop Updates
+
+**File:** `backend-spring/src/main/java/com/ulticode/modules/websocket/service/RealtimeService.java:167-193`
+
+**Issue:** In `flushPendingRankings`, there is a window between `pendingRankingUpdates.clear()` (line 170) and the re-mark at line 191 where any new `markDirty()` calls will be cleared on the NEXT flush, not the current one.
+
+```java
+Set dirty = Set.copyOf(pendingRankingUpdates.keySet());
+pendingRankingUpdates.clear(); // <-- Clears all, including ones just added
+
+for (String contestId : dirty) {
+ // ...
+ if (elapsed >= RANKING_THROTTLE_MS) {
+ // ...
+ } else {
+ pendingRankingUpdates.putIfAbsent(contestId, true); // Re-mark for next cycle
+ }
+}
+```
+
+If `markDirty("contest-A")` is called between `clear()` and the re-mark loop for "contest-A", it will NOT be re-marked (because `putIfAbsent` will overwrite with `true`, which was already the value). Wait -- `putIfAbsent` won't overwrite if the key exists, so this is actually safe in this specific case.
+
+However, the bigger issue: if `elapsed >= RANKING_THROTTLE_MS` (line 176) sends the update but then an exception occurs before `lastRankingPushTime.put()` (line 188), the pending entry is already cleared and the contest will not be re-marked. On next scheduled flush, there will be no entry for this contest.
+
+**Fix:** Consider a per-contest atomic operation:
+```java
+public void markDirty(String contestId) {
+ pendingRankingUpdates.compute(contestId, (k, v) -> Boolean.TRUE);
+}
+
+@Scheduled(fixedRate = 1000)
+public void flushPendingRankings() {
+ Map toFlush = new HashMap<>();
+ pendingRankingUpdates.forEach((contestId, dirty) -> {
+ Long lastPush = lastRankingPushTime.get(contestId);
+ long elapsed = System.currentTimeMillis() - (lastPush != null ? lastPush : 0);
+ if (elapsed >= RANKING_THROTTLE_MS) {
+ toFlush.put(contestId, dirty);
+ }
+ });
+
+ for (Map.Entry entry : toFlush.entrySet()) {
+ String contestId = entry.getKey();
+ pendingRankingUpdates.remove(contestId);
+ // ... emit and update lastRankingPushTime
+ }
+ // Entries not in toFlush remain for next cycle
+}
+```
+
+### WR-03: Rating Calculation Misses Users Without GlobalRanking
+
+**File:** `backend-spring/src/main/java/com/ulticode/modules/contest/service/impl/RatingCalculationServiceImpl.java:60-66`
+
+**Issue:** Per D-11, users without a `global_ranking` record are skipped. However, the rank assignment at lines 51-56 includes ALL participants, including those without global records. This creates an inconsistency -- two users could have the same final rank if one was skipped.
+
+```java
+for (int i = 0; i < participants.size(); i++) {
+ ContestParticipant p = participants.get(i);
+ p.setFinalRank(i + 1); // Skipped users still get ranks assigned
+ participantMapper.updateById(p);
+}
+```
+
+**Fix:** Either:
+1. Only assign final_rank to participants that will be rated, or
+2. Document that final_rank represents contest rank (regardless of rating eligibility)
+
+---
+
+## Info
+
+### IN-01: Typo in Variable Name
+
+**File:** `backend-spring/src/main/java/com/ulticode/modules/contest/service/impl/RatingCalculationServiceImpl.java:61`
+
+```java
+String oderId = participant.getUserId(); // "oderId" should be "userId"
+```
+
+### IN-02: Broad Catch in JudgeWorkerProcessor.onFailure
+
+**File:** `backend-spring/src/main/java/com/ulticode/modules/queue/processor/JudgeWorkerProcessor.java:203-221`
+
+**Issue:** The `onFailure` method catches `InterruptedException` and logs a warning, but the thread's interrupt status is not fully restored before the method returns. The `log.error` for exhausted retries also uses the `error` parameter twice in formatted output.
+
+```java
+} catch (InterruptedException e) {
+ Thread.currentThread().interrupt(); // Good
+ log.warn("Retry sleep interrupted for job {}", job.getId());
+} // Method exits here -- callers may not know the thread was interrupted
+```
+
+**Fix:** Consider propagating the interrupt or ensuring callers handle it. The current handling is acceptable for fire-and-forget retry scenarios, but worth documenting.
+
+---
+
+## Findings by Category
+
+| Category | Critical | Warning | Info |
+|----------|----------|---------|------|
+| Correctness (rating formula) | 1 | 0 | 0 |
+| Thread safety | 0 | 2 | 0 |
+| Race conditions | 0 | 1 | 0 |
+| Code quality | 0 | 0 | 2 |
+| **Total** | 1 | 3 | 2 |
+
+---
+
+## Reviewed Files Summary
+
+| File | Key Concerns |
+|------|-------------|
+| `ContestScheduler.java` | Race condition in status transitions (WR-01) |
+| `RatingCalculationServiceImpl.java` | Incorrect Elo formula (CR-01), skipped user inconsistency (WR-03), typo (IN-01) |
+| `RealtimeService.java` | Throttle flush can drop updates (WR-02) |
+| `JudgeWorkerProcessor.java` | Broad exception handling (IN-02) |
+| `SubmissionServiceImpl.java` | No issues found |
+| `Contest.java` | No issues found |
+| `RatingCalculationService.java` | Interface only, no issues |
+
+---
+
+_Reviewed: 2026-04-19T08:59:00Z_
+_Reviewer: Claude (gsd-code-reviewer)_
+_Depth: standard_
diff --git a/.planning/phases/14-contest-engine/14-VERIFICATION.md b/.planning/phases/14-contest-engine/14-VERIFICATION.md
new file mode 100644
index 000000000..1ad28a475
--- /dev/null
+++ b/.planning/phases/14-contest-engine/14-VERIFICATION.md
@@ -0,0 +1,88 @@
+---
+phase: 14-contest-engine
+verified: 2026-04-19T00:59:00Z
+status: passed
+score: 9/9 must-haves verified
+overrides_applied: 0
+gaps: []
+---
+
+# Phase 14: Contest Engine Verification Report
+
+**Phase Goal:** Contests run automatically with correct lifecycle transitions, participants earn accurate ratings after contests end, and real-time ranking updates are delivered via WebSocket
+**Verified:** 2026-04-19
+**Status:** passed
+**Re-verification:** No - initial verification
+
+## Goal Achievement
+
+### Observable Truths
+
+| # | Truth | Status | Evidence |
+|---|-------|--------|---------|
+| 1 | Contest ranking updates are pushed to /topic/contest/{contestId}/ranking at most once per second per contest | VERIFIED | `flushPendingRankings()` runs `@Scheduled(fixedRate = 1000)` with `RANKING_THROTTLE_MS = 1000` throttle check before push |
+| 2 | Submission verdict WebSocket payload includes contestId so frontend can correlate results to active contest | VERIFIED | `JudgeWorkerProcessor.pushResult()` passes `contestId` variable (not null) to `SubmissionResultPayload.of(submissionId, contestId, ...)` at line 298 |
+| 3 | Dirty contests are flushed after every submission verdict and by 1-second throttle scheduler | VERIFIED | `SubmissionServiceImpl.recordContestSubmissionIfNeeded()` calls `realtimeService.markDirty()` at line 585; `flushPendingRankings()` runs every 1 second |
+| 4 | ContestScheduler polls every 10 seconds and transitions UPCOMING->RUNNING when start_time is reached | VERIFIED | `@Scheduled(fixedRate = 10_000)` at line 29; `transitionToRunning()` called when `!contest.getStartTime().isAfter(now)` |
+| 5 | ContestScheduler transitions RUNNING->FINISHED when end_time is reached, recording actual_end_time | VERIFIED | `transitionToFinished()` sets `contest.setActualEndTime(LocalDateTime.now())` and status to FINISHED |
+| 6 | RatingCalculationService computes Codeforces Elo ratings and updates global_rankings and contest_participants.final_rank after contest ends | VERIFIED | `calculateAndUpdate()` sorts by score DESC/penalty ASC, assigns final_rank 1-based, calls `updateRating()` and `recalculateGlobalRanks()` |
+| 7 | Rating titles are assigned per D-08 thresholds (Newbie < 1200, Pupil < 1400, ... Legend < 3500) | VERIFIED | `fromRating()` static method covers all 10 levels with correct thresholds |
+| 8 | Transitions are idempotent (re-checked each poll, skip if already in target state) | VERIFIED | Both `transitionToRunning()` (line 65) and `transitionToFinished()` (line 89) re-check current status before writing |
+| 9 | Contest status changes are emitted via RealtimeService.emitContestStatus() | VERIFIED | Called in both `transitionToRunning()` (line 73) and `transitionToFinished()` (line 97) |
+
+**Score:** 9/9 truths verified
+
+### Required Artifacts
+
+| Artifact | Expected | Status | Details |
+|----------|----------|--------|---------|
+| `backend-spring/.../websocket/service/RealtimeService.java` | markDirty() and flushPendingRankings() throttle infrastructure | VERIFIED | Lines 159-194: `markDirty()` adds to pendingRankingUpdates; `flushPendingRankings()` @Scheduled(fixedRate=1000) with throttle check |
+| `backend-spring/.../queue/processor/JudgeWorkerProcessor.java` | SubmissionResultPayload includes contestId on verdict push | VERIFIED | Line 298: `SubmissionResultPayload.of(submissionId, contestId, problemId, userId, ...)` - contestId variable passed |
+| `backend-spring/.../submission/service/impl/SubmissionServiceImpl.java` | realtimeService.markDirty() called after contest submission recording | VERIFIED | Line 585: `realtimeService.markDirty(contest.getId())` after `contestSubmissionMapper.insert(cs)` |
+| `backend-spring/.../contest/scheduler/ContestScheduler.java` | @Scheduled job polling contests every 10s for lifecycle transitions | VERIFIED | Lines 29-50: `@Scheduled(fixedRate = 10_000)` run(), `transitionToRunning()` line 63, `transitionToFinished()` line 87, `computeEffectiveEndTime()` line 52 |
+| `backend-spring/.../contest/service/RatingCalculationService.java` | Interface for CF Elo rating computation | VERIFIED | `void calculateAndUpdate(String contestId)` method signature |
+| `backend-spring/.../contest/service/impl/RatingCalculationServiceImpl.java` | CF Elo implementation with K-factor 32/24/16, rating range 0-3500, 10 title levels | VERIFIED | `calculateNewRating()` lines 94-115, `determineKFactor()` lines 117-125, `fromRating()` lines 127-149 |
+
+### Key Link Verification
+
+| From | To | Via | Status | Details |
+|------|----|----|--------|---------|
+| SubmissionServiceImpl.recordContestSubmissionIfNeeded() | RealtimeService.markDirty() | call after ContestSubmission insert | WIRED | Line 585: `realtimeService.markDirty(contest.getId())` |
+| JudgeWorkerProcessor.pushResult() | SubmissionResultPayload.of(..., contestId, ...) | contestId passed as parameter | WIRED | Line 298: contestId variable passed (not null literal) |
+| ContestScheduler.transitionToFinished() | RatingCalculationService.calculateAndUpdate() | direct method call | WIRED | Line 101: `ratingService.calculateAndUpdate(contest.getId())` |
+| ContestScheduler.transitionToRunning() | RealtimeService.emitContestStatus() | WebSocket status push | WIRED | Lines 73-79 |
+| ContestScheduler.transitionToFinished() | RealtimeService.emitContestStatus() | WebSocket status push | WIRED | Lines 97-104 |
+| ContestScheduler.transitionToRunning() | RealtimeService.markDirty() | mark contest dirty after starting | WIRED | Line 82: `realtimeService.markDirty(contest.getId())` |
+| RealtimeService.flushPendingRankings() | RankingService.getLiveRanking() | service call in @Scheduled method | WIRED | Line 177: `rankingService.getLiveRanking(contestId, 200)` |
+
+### Data-Flow Trace (Level 4)
+
+| Artifact | Data Variable | Source | Produces Real Data | Status |
+|----------|---------------|--------|---------------------|--------|
+| RealtimeService.emitRankingUpdate() | List | RankingService.getLiveRanking() → ContestRankingVO mapping | Yes | FLOWING |
+
+Data flows through: Judge verdict → SubmissionServiceImpl.recordContestSubmissionIfNeeded() → markDirty() → flushPendingRankings() → rankingService.getLiveRanking() → emitRankingUpdate() → WebSocket
+
+### Behavioral Spot-Checks
+
+| Behavior | Command | Result | Status |
+|----------|---------|--------|--------|
+| Backend compiles successfully | `cd backend-spring && ./mvnw compile -q; echo EXIT_CODE: $?` | EXIT_CODE: 0 (BUILD SUCCESS) | PASS |
+
+### Requirements Coverage
+
+| Requirement | Source Plan | Description | Status | Evidence |
+|-------------|-------------|-------------|--------|----------|
+| CONTEST-03 | 14-02-PLAN.md | RatingCalculationService computes Codeforces Elo ratings | SATISFIED | CF Elo implementation in RatingCalculationServiceImpl.calculateAndUpdate() |
+| CONTEST-04 | 14-01-PLAN.md | Dirty contests flushed after submission verdict and by throttle scheduler | SATISFIED | markDirty() wired from SubmissionServiceImpl; flushPendingRankings() @Scheduled(fixedRate=1000) |
+| CONTEST-06 | 14-02-PLAN.md | Rating titles assigned per D-08 thresholds | SATISFIED | fromRating() static method covers all 10 levels |
+| JUDGE-04 | 14-01-PLAN.md | Submission verdict WebSocket payload includes contestId | SATISFIED | JudgeWorkerProcessor.pushResult() passes contestId (not null) to SubmissionResultPayload.of() |
+
+### Anti-Patterns Found
+
+No anti-patterns detected. Implementation is substantive with real data flow, proper wiring, and no stub indicators.
+
+---
+
+_Verified: 2026-04-19T00:59:00Z_
+_Verifier: Claude (gsd-verifier)_
diff --git a/.planning/phases/15-problem-user-enhancements/15-01-PLAN.md b/.planning/phases/15-problem-user-enhancements/15-01-PLAN.md
new file mode 100644
index 000000000..06a769d93
--- /dev/null
+++ b/.planning/phases/15-problem-user-enhancements/15-01-PLAN.md
@@ -0,0 +1,151 @@
+---
+wave: 1
+depends_on: []
+requirements_addressed: [PROB-01, PROB-02, USER-01, USER-02, USER-05]
+files_modified:
+ - backend-spring/src/main/java/com/ulticode/modules/problem/controller/ProblemController.java
+ - backend-spring/src/main/java/com/ulticode/modules/problem/service/ProblemService.java
+ - backend-spring/src/main/java/com/ulticode/modules/problem/service/impl/ProblemServiceImpl.java
+ - backend-spring/src/main/java/com/ulticode/modules/problem/dto/ProblemVO.java
+ - backend-spring/src/main/java/com/ulticode/modules/user/dto/UserStatsDTO.java
+ - backend-spring/src/main/java/com/ulticode/modules/user/service/UserService.java
+ - backend-spring/src/main/java/com/ulticode/modules/user/service/impl/UserServiceImpl.java
+autonomous: true
+---
+
+## Plan 15-01: Problem Random + Stats Enrichment
+
+
+
+Implement PROB-01 (random problem endpoint), PROB-02 (acceptance rate calculation), USER-01 (global rank), USER-02 (acceptance rate), and USER-05 (submission count) as backend API enhancements to existing endpoints.
+
+
+
+
+- backend-spring/src/main/java/com/ulticode/modules/problem/entity/Problem.java
+- backend-spring/src/main/java/com/ulticode/modules/problem/dto/ProblemVO.java
+- backend-spring/src/main/java/com/ulticode/modules/user/dto/UserStatsDTO.java
+- backend-spring/src/main/java/com/ulticode/modules/problem/controller/ProblemController.java
+- backend-spring/src/main/java/com/ulticode/modules/user/controller/UserController.java
+- db-manager/migrations/V1__initial_schema.sql (submissions table structure)
+- db-manager/migrations/V3__contest_schema.sql (global_rankings table)
+
+
+
+
+### PROB-01: GET /problems/random
+
+1. Add to `ProblemService` interface:
+ ```java
+ ProblemVO findRandomPublished();
+ ```
+
+2. Add to `ProblemServiceImpl`:
+ ```java
+ @Override
+ public ProblemVO findRandomPublished() {
+ LambdaQueryWrapper wrapper = new LambdaQueryWrapper()
+ .eq(Problem::getIsPublished, true)
+ .last("ORDER BY RAND() LIMIT 1");
+ Problem problem = this.getOne(wrapper);
+ if (problem == null) {
+ throw new BusinessException("No published problems available");
+ }
+ return ProblemVO.from(problem);
+ }
+ ```
+
+3. Add to `ProblemController`:
+ ```java
+ @Operation(summary = "Get a random published problem")
+ @GetMapping("/random")
+ public Result getRandomProblem() {
+ return Result.success(problemService.findRandomPublished());
+ }
+ ```
+
+### PROB-02: Acceptance Rate in ProblemVO
+
+1. Add `acceptanceRate` field to `ProblemVO`:
+ ```java
+ @JsonProperty("acceptance_rate")
+ private Double acceptanceRate;
+ ```
+
+2. Add static factory method with acceptance rate:
+ ```java
+ public static ProblemVO from(Problem problem, Double acceptanceRate) {
+ ProblemVO vo = from(problem);
+ vo.setAcceptanceRate(acceptanceRate);
+ return vo;
+ }
+ ```
+
+3. Add SQL aggregation to `ProblemServiceImpl.findAll()` or create a dedicated method:
+ ```java
+ // In a query method that returns problem list, join with submissions:
+ // SELECT p.*, SUM(s.status='Accepted') / COUNT(*) * 100 as acceptance_rate
+ // FROM problems p LEFT JOIN submissions s ON p.id = s.problem_id
+ // WHERE p.is_published = true GROUP BY p.id
+ ```
+
+4. For single problem fetch (`getById`), add acceptance rate query:
+ ```java
+ Double acceptanceRate = submissionService.getAcceptanceRateByProblemId(problemId);
+ ```
+
+### USER-01: Global Rank in UserStatsDTO
+
+1. Add fields to `UserStatsDTO`:
+ ```java
+ private Integer globalRank;
+ private Double acceptanceRate;
+ private Long submissionCount;
+ ```
+
+2. Update `UserServiceImpl.getUserStatsById()` to populate new fields:
+ ```java
+ // Global rank via window function subquery:
+ String rankSql = "SELECT t.rank FROM (" +
+ "SELECT user_id, RANK() OVER (ORDER BY rating DESC) as rank " +
+ "FROM global_rankings WHERE user_id = ?" +
+ ") t WHERE t.user_id = ?";
+
+ // Acceptance rate:
+ String acceptanceSql = "SELECT " +
+ "SUM(CASE WHEN status = 'Accepted' THEN 1 ELSE 0 END) * 100.0 / COUNT(*) " +
+ "FROM submissions WHERE user_id = ?";
+
+ // Submission count:
+ String countSql = "SELECT COUNT(*) FROM submissions WHERE user_id = ?";
+ ```
+
+### USER-02 & USER-05: Acceptance Rate + Submission Count
+
+Both computed in same SQL query as global rank above — populate `acceptanceRate` and `submissionCount` in `UserStatsDTO`.
+
+
+
+
+
+- [ ] `GET /problems/random` returns a random published problem with status 200
+- [ ] `ProblemVO` has `acceptanceRate` field populated on list and detail endpoints
+- [ ] `UserStatsDTO` has `globalRank`, `acceptanceRate`, `submissionCount` fields
+- [ ] `GET /users/{id}/stats` returns all three new fields populated
+- [ ] All new fields are non-null (use 0 or null for users with no data)
+
+
+
+
+
+```
+# Test random problem
+curl -s http://localhost:9001/problems/random | grep -o '"id":"[^"]*"'
+
+# Test stats enrichment (as authenticated user)
+curl -s http://localhost:9001/users/1/stats | grep -o '"globalRank":[0-9]*'
+curl -s http://localhost:9001/users/1/stats | grep -o '"acceptanceRate":[0-9.]*'
+curl -s http://localhost:9001/users/1/stats | grep -o '"submissionCount":[0-9]*'
+```
+
+
diff --git a/.planning/phases/15-problem-user-enhancements/15-02-PLAN.md b/.planning/phases/15-problem-user-enhancements/15-02-PLAN.md
new file mode 100644
index 000000000..2c0c737a8
--- /dev/null
+++ b/.planning/phases/15-problem-user-enhancements/15-02-PLAN.md
@@ -0,0 +1,201 @@
+---
+wave: 2
+depends_on: []
+requirements_addressed: [PROB-03, PROB-04, USER-03, USER-04]
+files_modified:
+ - backend-spring/src/main/java/com/ulticode/modules/admin/controller/AdminProblemController.java
+ - backend-spring/src/main/java/com/ulticode/modules/admin/service/AdminProblemService.java
+ - backend-spring/src/main/java/com/ulticode/modules/admin/service/impl/AdminProblemServiceImpl.java
+ - backend-spring/src/main/java/com/ulticode/modules/problem/dto/CreateProblemDTO.java
+ - backend-spring/src/main/java/com/ulticode/modules/problem/service/impl/ProblemServiceImpl.java
+ - backend-spring/src/main/java/com/ulticode/modules/achievement/controller/AchievementController.java
+ - console/src/router/index.ts
+ - console/src/views/users/UserProfileView.vue
+autonomous: true
+---
+
+## Plan 15-02: Admin Bulk Ops + Extended DTO + Achievement Aliases + Public Profile
+
+
+
+Implement PROB-03 (admin bulk operations), PROB-04 (extended CreateProblemDTO), USER-03 (public user profile routing), USER-04 (achievement path aliases).
+
+
+
+
+- backend-spring/src/main/java/com/ulticode/modules/admin/controller/AdminProblemController.java
+- backend-spring/src/main/java/com/ulticode/modules/admin/service/AdminProblemService.java
+- backend-spring/src/main/java/com/ulticode/modules/problem/dto/CreateProblemDTO.java
+- backend-spring/src/main/java/com/ulticode/modules/problem/entity/ProblemDetail.java
+- backend-spring/src/main/java/com/ulticode/modules/problem/entity/ProblemLanguage.java
+- backend-spring/src/main/java/com/ulticode/modules/problem/entity/ProblemTagRelation.java
+- backend-spring/src/main/java/com/ulticode/modules/achievement/controller/AchievementController.java
+- console/src/router/index.ts
+- management/src/api/problems.ts (bulkAction method)
+
+
+
+
+### PROB-03: POST /admin/problems/bulk
+
+1. Create `BulkProblemRequestDTO`:
+ ```java
+ @Data
+ public class BulkProblemRequestDTO {
+ @NotEmpty private List ids;
+ @NotNull private BulkAction action; // publish, unpublish, delete, edit
+ private Map params; // optional: { difficulty: "Easy" }
+ }
+
+ public enum BulkAction { publish, unpublish, delete, edit }
+ ```
+
+2. Create `BulkProblemResultDTO`:
+ ```java
+ @Data
+ public class BulkProblemResultDTO {
+ private String id;
+ private boolean success;
+ private String error;
+ }
+ ```
+
+3. Add to `AdminProblemService`:
+ ```java
+ List bulkAction(BulkProblemRequestDTO request);
+ ```
+
+4. Implement in `AdminProblemServiceImpl`:
+ ```java
+ @Override
+ public List bulkAction(BulkProblemRequestDTO request) {
+ List results = new ArrayList<>();
+ for (String id : request.getIds()) {
+ try {
+ switch (request.getAction()) {
+ case publish -> problemService.publishProblem(id);
+ case unpublish -> problemService.unpublishProblem(id);
+ case delete -> problemService.deleteProblem(id);
+ case edit -> {
+ Map p = request.getParams();
+ if (p != null && p.containsKey("difficulty")) {
+ problemService.updateDifficulty(id, (String) p.get("difficulty"));
+ }
+ }
+ }
+ results.add(new BulkProblemResultDTO(id, true, null));
+ } catch (Exception e) {
+ results.add(new BulkProblemResultDTO(id, false, e.getMessage()));
+ }
+ }
+ return results;
+ }
+ ```
+
+5. Add to `AdminProblemController`:
+ ```java
+ @PostMapping("/problems/bulk")
+ public Result> bulkAction(@Valid @RequestBody BulkProblemRequestDTO request) {
+ return Result.success(adminProblemService.bulkAction(request));
+ }
+ ```
+
+### PROB-04: Extend CreateProblemDTO
+
+1. Add fields to `CreateProblemDTO`:
+ ```java
+ @Schema(description = "Problem summary")
+ private String summary;
+
+ @Schema(description = "Problem content (markdown)")
+ private String content;
+
+ @Schema(description = "Examples as JSON array")
+ private String examples; // JSON: [{"input": "...", "output": "...", "explanation": "..."}]
+
+ @Schema(description = "Constraints")
+ private String constraints;
+
+ @Schema(description = "Hints as JSON array")
+ private String hints; // JSON: ["hint1", "hint2"]
+
+ @Schema(description = "Supported languages as JSON array")
+ private List languages; // ["javascript", "python", "java", "c", "cpp"]
+
+ @Schema(description = "Tags as JSON array")
+ private List tags; // ["array", "dynamic-programming"]
+ ```
+
+2. Update `ProblemServiceImpl.createProblem()` to:
+ - Create `ProblemDetail` record and save it
+ - Create `ProblemLanguage` records for each language
+ - Create `ProblemTagRelation` records for each tag
+ - Store all associations properly
+
+### USER-04: Achievement Path Aliases
+
+Add two alias endpoints to `AchievementController`:
+
+```java
+// Alias for frontend /achievements/my
+@GetMapping("/my")
+public Result> getCurrentUserAchievementsAlias() {
+ return getCurrentUserAchievements();
+}
+
+// Alias for frontend /achievements/points
+@GetMapping("/points")
+public Result getCurrentUserPointsAlias() {
+ return getCurrentUserPoints();
+}
+```
+
+### USER-03: Public User Profile Page
+
+1. Add route to `console/src/router/index.ts`:
+ ```typescript
+ {
+ path: '/users/:id',
+ name: 'user-profile',
+ component: () => import('@/views/users/UserProfileView.vue'),
+ meta: { requiresAuth: true }
+ }
+ ```
+
+2. Create `console/src/views/users/UserProfileView.vue`:
+ - Uses `userApi.getUserById(id)` to fetch public profile
+ - Uses `userStatsApi.getStats(id)` to fetch user stats
+ - Displays: username, join date, global rank, acceptance rate, submission count, solved problems breakdown
+ - Reuse layout and components similar to `PersonalDashboardView.vue`
+
+
+
+
+
+- [ ] `POST /admin/problems/bulk` accepts `{ ids: [...], action: "publish" }` and returns per-item results
+- [ ] `POST /admin/problems/bulk` with action `"edit"` and `params: { difficulty: "Easy" }` updates difficulty
+- [ ] `CreateProblemDTO` accepts all fields: summary, content, examples, constraints, hints, languages, tags
+- [ ] `GET /achievements/my` returns same as `GET /achievements/user/me`
+- [ ] `GET /achievements/points` returns same as `GET /achievements/user/me/points`
+- [ ] `/users/:id` route exists in console router
+- [ ] `UserProfileView.vue` renders public user data without requiring special permissions
+
+
+
+
+
+```bash
+# Test bulk action
+curl -X POST http://localhost:9001/admin/problems/bulk \
+ -H "Content-Type: application/json" \
+ -d '{"ids":["1","2"],"action":"publish"}' | grep -o '"success":true'
+
+# Test achievement aliases
+curl -s http://localhost:9001/achievements/my -H "Authorization: Bearer $TOKEN" | head -c 200
+curl -s http://localhost:9001/achievements/points -H "Authorization: Bearer $TOKEN"
+
+# Verify router has /users/:id route
+grep -n "users/:id" console/src/router/index.ts
+```
+
+
diff --git a/.planning/phases/15-problem-user-enhancements/15-CONTEXT.md b/.planning/phases/15-problem-user-enhancements/15-CONTEXT.md
new file mode 100644
index 000000000..1dd6a8369
--- /dev/null
+++ b/.planning/phases/15-problem-user-enhancements/15-CONTEXT.md
@@ -0,0 +1,177 @@
+# Phase 15: Problem + User Enhancements - Context
+
+**Gathered:** 2026-04-19
+**Status:** Ready for planning
+
+
+## Phase Boundary
+
+Implement missing backend endpoints for problem browsing and user profile features: random problem API, acceptance rate calculation, admin bulk operations, extended problem creation DTO, user stats enrichment (global rank, acceptance rate, submission count), public user profile page routing, and achievement API path alignment.
+
+**Scope:**
+- PROB-01: `GET /problems/random` endpoint returning one random published problem
+- PROB-02: Acceptance rate calculation on problem list/detail — compute from `submissions` table (accepted_count / total_count)
+- PROB-03: `POST /admin/problems/bulk` endpoint for publish/unpublish/delete/edit difficulty
+- PROB-04: Extend `CreateProblemDTO` with summary, content, examples, constraints, hints, languages, tags
+- USER-01: Add `globalRank` to `UserStatsDTO` — rank by rating from `global_rankings` table
+- USER-02: Add `acceptanceRate` to `UserStatsDTO` — accepted_submissions / total_submissions for user
+- USER-03: Add `/users/:id` route to console router + UserProfileView page
+- USER-04: Add alias endpoints `/achievements/my` → `/achievements/user/me`, `/achievements/points` → `/achievements/user/me/points`
+- USER-05: Add `submissionCount` to `UserStatsDTO` — total submissions from `submissions` table
+
+**Out of scope:**
+- User comparison feature — deferred
+- Social profile sharing/meta tags — deferred
+- Following/followers social graph — deferred
+- Version history for problems — deferred
+- Problem import/export — deferred
+- Flag/moderation system for problems — deferred
+
+
+
+
+## Implementation Decisions
+
+### Problem Random (PROB-01)
+- **D-01:** `GET /problems/random` — return one random published problem, no auth required
+- **D-02:** Uses existing `ProblemService` with new `findRandomPublished()` method — entity query with `isPublished = true`, random order via SQL `ORDER BY RAND()`
+
+### Acceptance Rate Calculation (PROB-02)
+- **D-03:** Calculate on read: `acceptance_rate = accepted_count / total_count * 100` from `submissions` table grouped by problem
+- **D-04:** Update `ProblemVO` to include `acceptanceRate` field — computed per query, not stored
+- **D-05:** Cache-friendly: calculate in SQL aggregation, not application-side loop
+
+### Admin Bulk Operations (PROB-03)
+- **D-06:** `POST /admin/problems/bulk` — accepts `{ ids: string[], action: 'publish' | 'unpublish' | 'delete' | 'edit', params?: { difficulty?: string } }`
+- **D-07:** Returns `{ results: [{ id, success, error? }] }` — per-item success/failure for partial feedback
+- **D-08:** Batch update in MyBatis-Plus via `updateBatchByIds` or `update(null, lambdaUpdate().in(...).set(...)`
+
+### Extended Problem DTO (PROB-04)
+- **D-09:** Add fields to `CreateProblemDTO`: summary, content, examples (JSON), constraints, hints (JSON), languages (JSON array), tags (JSON array)
+- **D-10:** Update `ProblemService.createProblem()` to accept full problem detail (ProblemDetail + ProblemLanguage + ProblemTagRelation records)
+- **D-11:** ProblemDetail stored separately from Problem — one-to-one via `problem_detail` table
+
+### User Global Rank (USER-01)
+- **D-12:** `globalRank` in `UserStatsDTO` — computed as `RANK() OVER (ORDER BY rating DESC)` from `global_rankings` table
+- **D-13:** Join user with global_rankings on userId, use window function or subquery for rank
+
+### User Acceptance Rate (USER-02)
+- **D-14:** `acceptanceRate` in `UserStatsDTO` — user's accepted submissions / total submissions * 100
+- **D-15:** Single SQL aggregation: `SUM(status='Accepted') / COUNT(*) * 100` from `submissions` where user_id = ?
+
+### Public User Profile (USER-03)
+- **D-16:** `GET /users/{id}` already exists in `UserController` — returns `UserVO` (public fields only)
+- **D-17:** Add `/users/:id` route to console router pointing to `UserProfileView.vue`
+- **D-18:** `UserProfileView` uses `userApi.getUserById(id)` and `userStatsApi.getStats(id)` — both endpoints already exist
+
+### Achievement Path Alignment (USER-04)
+- **D-19:** Add alias endpoints in `AchievementController`:
+ - `GET /achievements/my` → delegate to `getCurrentUserAchievements()`
+ - `GET /achievements/points` → delegate to `getCurrentUserPoints()`
+- **D-20:** Keep existing `/achievements/user/me` and `/achievements/user/me/points` as canonical — add aliases for frontend compatibility
+
+### User Submission Count (USER-05)
+- **D-21:** `submissionCount` in `UserStatsDTO` — total submissions from `submissions` table for user
+- **D-22:** Add `submissionCount` field to `UserStatsDTO` and populate via SQL count
+
+### Claude's Discretion
+- Random problem SQL: `ORDER BY RAND()` sufficient for MVP (not optimized for large datasets)
+- Bulk action transaction: each item succeeds/fails independently — no full rollback on single failure
+- Achievement alias vs path change: aliases preserve existing backend paths while satisfying frontend
+
+
+
+
+## Canonical References
+
+**Downstream agents MUST read these before planning or implementing.**
+
+### Existing Backend
+- `backend-spring/src/main/java/com/ulticode/modules/problem/entity/Problem.java` — Problem entity with `acceptance_rate` column
+- `backend-spring/src/main/java/com/ulticode/modules/problem/dto/CreateProblemDTO.java` — Current limited DTO (only slug/title/difficulty/isPremium/isPublished)
+- `backend-spring/src/main/java/com/ulticode/modules/problem/entity/ProblemDetail.java` — Separate detail entity (summary, content, examples, constraints, hints)
+- `backend-spring/src/main/java/com/ulticode/modules/problem/entity/ProblemLanguage.java` — Language support entity
+- `backend-spring/src/main/java/com/ulticode/modules/problem/entity/ProblemTagRelation.java` — Tag relation entity
+- `backend-spring/src/main/java/com/ulticode/modules/problem/controller/ProblemController.java` — Existing problem endpoints
+- `backend-spring/src/main/java/com/ulticode/modules/user/dto/UserStatsDTO.java` — Current DTO missing globalRank, acceptanceRate, submissionCount
+- `backend-spring/src/main/java/com/ulticode/modules/user/controller/UserController.java` — Has `GET /users/{id}/stats` and `GET /users/{id}` (existing infrastructure)
+- `backend-spring/src/main/java/com/ulticode/modules/achievement/controller/AchievementController.java` — Has `/achievements/user/me` and `/achievements/user/me/points`; needs `/achievements/my` and `/achievements/points` aliases
+
+### Existing Frontend
+- `console/src/api/problem.ts` — `fetchRandomProblem()` calls `GET /problems/random` (endpoint missing)
+- `console/src/api/user.ts` — `getUserById(id)` calls `GET /users/${id}` (endpoint exists)
+- `console/src/api/userStats.ts` — `getStats(userId)` calls `GET /users/${userId}/stats` (endpoint exists)
+- `console/src/api/achievement.ts` — `getUserAchievements()` calls `GET /achievements/my`, `getUserPoints()` calls `GET /achievements/points` (endpoints missing)
+- `console/src/stores/userStats.ts` — Pinia store using `userStatsApi.getStats(authStore.userId)`
+- `console/src/views/dashboard/PersonalDashboardView.vue` — Shows stats with easyProgress/mediumProgress/hardProgress/totalProgress
+- `management/src/views/problems/composables/useProblemActions.ts` — `bulkAction()` calls `problemsApi.bulkAction()` (endpoint missing)
+- `management/src/stores/admin/problems.ts` — `bulkAction()` and `bulkEdit()` methods defined
+
+### Database Schema
+- `db-manager/migrations/V1__initial_schema.sql` — `submissions` table with `status` column (Accepted/Wrong Answer/etc.)
+- `db-manager/migrations/V1__initial_schema.sql` — `problems` table with `acceptance_rate` column (stored, to be computed)
+- `db-manager/migrations/V3__contest_schema.sql` — `global_rankings` table with `rating` column for rank calculation
+
+### Prior Phase Context
+- `.planning/phases/14-contest-engine/14-CONTEXT.md` — Rating calculation, real-time ranking, WebSocket push patterns
+- `.planning/phases/13-contest-data-layer/13-CONTEXT.md` — Entity/service patterns, MyBatis-Plus usage
+
+
+
+
+## Existing Code Insights
+
+### Reusable Assets
+- **UserController**: Already has `GET /users/{id}` and `GET /users/{id}/stats` — just need to extend `UserStatsDTO`
+- **AchievementController**: Already has the logic for achievements — just need alias endpoints
+- **ProblemService**: Has existing problem query infrastructure — new random method fits existing pattern
+- **Submission entity**: Has `status` field — can aggregate for acceptance rate
+
+### Established Patterns
+- **MyBatis-Plus query patterns**: Use `QueryWrapper` for dynamic SQL, `lambdaQuery()` for type-safe queries
+- **Service layer**: Business logic in `*ServiceImpl`, thin controller delegates to service
+- **DTO pattern**: Request DTOs with validation annotations (`@NotBlank`, `@Pattern`, etc.)
+
+### Integration Points
+- **Console router**: Add `/users/:id` route to `console/src/router/index.ts`
+- **UserStatsDTO**: Extend with 3 new fields (globalRank, acceptanceRate, submissionCount)
+- **AchievementController**: Add 2 alias endpoints mapping frontend paths to existing handlers
+
+### Critical Gaps
+- No `GET /problems/random` endpoint
+- No `POST /admin/problems/bulk` endpoint
+- `UserStatsDTO` missing globalRank, acceptanceRate, submissionCount
+- Achievement paths `/achievements/my` and `/achievements/points` not implemented
+- No `/users/:id` route in console router for public profiles
+
+
+
+
+## Specific Ideas
+
+- Acceptance rate formula: `SUM(CASE WHEN status = 'Accepted' THEN 1 ELSE 0 END) / COUNT(*) * 100 AS acceptance_rate`
+- Global rank: `SELECT rank FROM (SELECT user_id, RANK() OVER (ORDER BY rating DESC) as rank FROM global_rankings) t WHERE user_id = ?`
+- Submission count: Simple `COUNT(*)` from `submissions` WHERE `user_id = ?`
+
+
+
+
+## Deferred Ideas
+
+### Reviewed Todos (not folded)
+None — no pending todos matched this phase.
+
+### Scope Creep Redirected
+- User comparison feature — new capability, belongs in future phase
+- Social profile sharing / meta tags — new capability, belongs in future phase
+- Following/followers social graph — new capability, belongs in future phase
+- Problem version history (6 endpoints) — deferred to future phase
+- Problem import/export — deferred to future phase
+
+
+
+---
+
+*Phase: 15-problem-user-enhancements*
+*Context gathered: 2026-04-19*
+*Auto mode: all gray areas selected, recommended options applied*
diff --git a/.planning/phases/15-problem-user-enhancements/15-DISCUSSION-LOG.md b/.planning/phases/15-problem-user-enhancements/15-DISCUSSION-LOG.md
new file mode 100644
index 000000000..1c164fcdb
--- /dev/null
+++ b/.planning/phases/15-problem-user-enhancements/15-DISCUSSION-LOG.md
@@ -0,0 +1,134 @@
+# Phase 15: Problem + User Enhancements - Discussion Log
+
+> **Audit trail only.** Do not use as input to planning, research, or execution agents.
+> Decisions are captured in CONTEXT.md — this log preserves the alternatives considered.
+
+**Date:** 2026-04-19
+**Phase:** 15-problem-user-enhancements
+**Mode:** Auto (--auto) — all gray areas selected, recommended options applied
+
+---
+
+## Area: Random Problem (PROB-01)
+
+| Option | Description | Selected |
+|--------|-------------|----------|
+| SQL RAND() | `ORDER BY RAND()` — simple, works for MVP | ✓ |
+| Custom index shuffle | Application-side random with seeded query | |
+| Dedicated random endpoint | New controller vs extend existing ProblemService | ✓ (extend existing) |
+
+**Decision:** `GET /problems/random` via ProblemService.findRandomPublished() with SQL ORDER BY RAND()
+**Auto rationale:** Simplest approach that satisfies the requirement without over-engineering.
+
+---
+
+## Area: Acceptance Rate Calculation (PROB-02)
+
+| Option | Description | Selected |
+|--------|-------------|----------|
+| Stored column | Update `acceptance_rate` on each submission | |
+| Computed per query | SQL aggregation on submissions table per request | ✓ |
+| Cached with TTL | Compute once, cache in Redis, invalidate on new submission | |
+
+**Decision:** Calculate on read via SQL aggregation — no stale data, no cache invalidation complexity
+**Auto rationale:** Simpler than cache invalidation, accurate by default.
+
+---
+
+## Area: Admin Bulk Operations (PROB-03)
+
+| Option | Description | Selected |
+|--------|-------------|----------|
+| Per-item response | `{ results: [{ id, success, error? }] }` — partial success supported | ✓ |
+| Full rollback | All-or-nothing transaction | |
+| Single action per request | Separate endpoints per action type | |
+
+**Decision:** Per-item response with partial success — aligns with existing frontend `bulkAction()` UI
+**Auto rationale:** Frontend already expects per-item results from `problemsApi.bulkAction()`.
+
+---
+
+## Area: Extended Problem DTO (PROB-04)
+
+| Option | Description | Selected |
+|--------|-------------|----------|
+| Extend CreateProblemDTO | Add summary, content, examples, constraints, hints, languages, tags | ✓ |
+| Separate CreateDetailDTO | New DTO for ProblemDetail, keep CreateProblemDTO minimal | |
+| JSON field approach | Single JSON field for all extended data | |
+
+**Decision:** Extend CreateProblemDTO — aligns with admin frontend `bulkEdit()` needing full problem fields
+**Auto rationale:** Admin create page needs all fields; extending existing DTO is straightforward.
+
+---
+
+## Area: User Global Rank (USER-01)
+
+| Option | Description | Selected |
+|--------|-------------|----------|
+| Window function | `RANK() OVER (ORDER BY rating DESC)` in SQL | ✓ |
+| Application-side sort | Load all rankings, sort in Java | |
+| Separate rank column | Store rank in global_rankings, update on rating change | |
+
+**Decision:** Window function — single query, always current, no denormalization
+**Auto rationale:** Standard SQL approach, efficient, no stale rank data.
+
+---
+
+## Area: User Acceptance Rate (USER-02)
+
+| Option | Description | Selected |
+|--------|-------------|----------|
+| SQL aggregation | `SUM(status='Accepted') / COUNT(*)` per user | ✓ |
+| Submission count + separate query | Two queries: total and accepted | |
+| Cached in user record | Store acceptance_rate in users table | |
+
+**Decision:** SQL aggregation — single query, accurate, no cache invalidation
+**Auto rationale:** Consistent with PROB-02 approach (computed on read).
+
+---
+
+## Area: Public User Profile (USER-03)
+
+| Option | Description | Selected |
+|--------|-------------|----------|
+| Reuse existing endpoints | `GET /users/{id}` + `GET /users/{id}/stats` already exist | ✓ |
+| New public profile endpoint | Separate endpoint with limited fields | |
+| Frontend-only solution | Single page component, no backend change | |
+
+**Decision:** Backend already has the endpoints — just need console router + view page
+**Auto rationale:** Backend infrastructure already in place; minimal new work needed.
+
+---
+
+## Area: Achievement Path Alignment (USER-04)
+
+| Option | Description | Selected |
+|--------|-------------|----------|
+| Add alias endpoints | `/achievements/my` → existing handler, `/achievements/points` → existing handler | ✓ |
+| Change frontend paths | Update console to call `/achievements/user/me` | |
+| Redirect at gateway | Nginx/header-level path rewrite | |
+
+**Decision:** Alias endpoints — preserves existing backend paths, adds frontend-compatible routes
+**Auto rationale:** Minimal backend change, no frontend changes needed, backward compatible.
+
+---
+
+## Area: User Submission Count (USER-05)
+
+| Option | Description | Selected |
+|--------|-------------|----------|
+| Add to UserStatsDTO | `submissionCount` field alongside existing stats | ✓ |
+| Separate endpoint | `GET /users/{id}/submission-count` | |
+| Inline in existing count query | Add COUNT to existing user stats SQL | ✓ (combined) |
+
+**Decision:** Combined into existing UserStatsDTO SQL query — single endpoint, no new routes
+**Auto rationale:** Already querying submissions table for acceptance rate; add COUNT to same query.
+
+---
+
+## Summary
+
+**Gray areas resolved:** 9/9 (all)
+**Mode:** Auto — all decisions follow recommended defaults
+**Deferred ideas noted:** 5 (user comparison, social sharing, followers, problem version history, import/export)
+
diff --git a/CLAUDE.md b/CLAUDE.md
index 218d8bf7e..43bb0d22b 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -94,6 +94,13 @@ cd management && pnpm build
cd backend-spring && ./mvnw package -DskipTests
```
+### Known Pitfalls
+
+- **ESLint compatibility**: Console uses ESLint 9.x — `eslint-plugin-vue` must be `^9.30.0`, not 10.x (TypeScript peer dep conflict)
+- **vitest setupFiles**: Do not add setup file paths that don't exist; vitest will fail to resolve them
+- **pnpm build scripts**: Use `.npmrc` `onlyBuiltDependencies` field instead of `pnpm approve-builds` for CI
+- **Recommendation build order**: `recommendation` module must be built (`mvn install -DskipTests`) BEFORE `backend-spring` — backend depends on `recommend-api`
+
## Service Architecture
```
@@ -123,7 +130,7 @@ cd backend-spring && ./mvnw package -DskipTests
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────────────┐
│ MySQL (23306) │ │ Redis (26379) │ │ Recommendation Service │
│ Primary DB │ │ Cache, Sessions │ │ Dubbo3 + Spark (9004) │
-│ Prisma schema │ │ Rate Limiting │ │ Optional, Nacos (28848) │
+│ MyBatis-Plus │ │ Rate Limiting │ │ Optional, Nacos (28848) │
└─────────────────┘ └─────────────────┘ └─────────────────────────┘
```
@@ -241,6 +248,70 @@ Frontend uses Vite env vars (`VITE_API_BASE_URL`).
- Swagger UI: `http://localhost:9001/swagger-ui.html`
- Health check: `curl http://localhost:9001/actuator/health`
+## Code Search Tools
+
+### Grep (ripgrep)
+
+Built-in `Grep` tool wraps ripgrep — always prefer it over `grep`/`rg` Bash commands.
+
+```yaml
+# 按内容搜索文件
+pattern: "TODO|FIXME"
+glob: "*.java" # 按文件类型过滤
+path: "backend-spring" # 限定目录
+output_mode: "content" # content | files_with_matches | count
+-i: true # 忽略大小写
+context: 3 # 上下文行数（等同 -C）
+
+# 常用模式
+pattern: "class\\s+\\w+Controller" # 正则匹配 Controller 类
+pattern: "apiGet|apiPost" # 搜索 API 调用
+glob: "*.{vue,ts}" # 多种扩展名
+multiline: true # 跨行匹配
+```
+
+**经验法则**：
+- 精确路径 → `Glob`（按文件名模式找文件）
+- 精确内容 → `Grep`（按内容搜索）
+- 模糊/多轮搜索 → Agent（`Explore` 类型，适合复杂探索）
+
+### ast-grep (AST 模式搜索与替换)
+
+ast-grep 基于 AST 匹配，比文本正则更精确。通过 MCP 工具 `ast_grep_search` / `ast_grep_replace` 使用。
+
+**元变量**：`$NAME` 匹配单个节点，`$$$ARGS` 匹配多个节点。
+
+```yaml
+# 搜索模式
+pattern: "console.log($MSG)" # 找所有 console.log
+pattern: "function $NAME($$$ARGS)" # 找所有函数声明
+pattern: "$X === null" # 找 null 相等检查
+pattern: "if ($COND) { $$$BODY }" # 找所有 if 语句
+language: "typescript" # javascript|typescript|tsx|python|java|kotlin|go|rust|c|cpp|html|css|json|yaml
+path: "console/src" # 限定目录
+maxResults: 20 # 限制结果数
+
+# 替换模式（dryRun=true 默认只预览，设 false 应用）
+pattern: "console.log($MSG)"
+replacement: "logger.info($MSG)"
+language: "typescript"
+dryRun: false # 设为 false 实际执行
+
+# Java 示例 — 查找 @GetMapping 方法
+pattern: "@GetMapping($PATH)$$$PUBLIC $RET $NAME($$$ARGS) { $$$BODY }"
+language: "java"
+
+# Vue/TSX 示例 — 查找 v-if 指令对
+pattern: "class=\"$CLS\""
+replacement: "className=\"$CLS\""
+language: "tsx"
+```
+
+**适用场景**：
+- 精确重构（重命名模式、批量替换）→ `ast_grep_replace`
+- 查找特定代码结构（所有 catch 块、所有 import）→ `ast_grep_search`
+- 纯文本/关键字搜索 → `Grep` 更轻量
+
## Frontend Design System
Both `console/` and `management/` share a unified Solarized color palette using OKLCH color space with `--radius: 0` (sharp corners). Reference the local skills for detailed specs:
@@ -349,3 +420,65 @@ Do not skip skills, ignore gstack errors, or work around missing gstack.
Using gstack skills: After install, skills like /qa, /ship, /review, /investigate,
and /browse are available. Use /browse for all web browsing.
Use ~/.claude/skills/gstack/... for gstack file paths (the global path).
+
+## Behavioral Guidelines
+
+These guidelines bias toward caution over speed. For trivial tasks, use judgment.
+
+### Think Before Coding
+
+**Don't assume. Don't hide confusion. Surface tradeoffs.**
+
+Before implementing:
+- State your assumptions explicitly. If uncertain, ask.
+- If multiple interpretations exist, present them - don't pick silently.
+- If a simpler approach exists, say so. Push back when warranted.
+- If something is unclear, stop. Name what's confusing. Ask.
+
+### Simplicity First
+
+**Minimum code that solves the problem. Nothing speculative.**
+
+- No features beyond what was asked.
+- No abstractions for single-use code.
+- No "flexibility" or "configurability" that wasn't requested.
+- No error handling for impossible scenarios.
+- If you write 200 lines and it could be 50, rewrite it.
+
+Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
+
+### Surgical Changes
+
+**Touch only what you must. Clean up only your own mess.**
+
+When editing existing code:
+- Don't "improve" adjacent code, comments, or formatting.
+- Don't refactor things that aren't broken.
+- Match existing style, even if you'd do it differently.
+- If you notice unrelated dead code, mention it - don't delete it.
+
+When your changes create orphans:
+- Remove imports/variables/functions that YOUR changes made unused.
+- Don't remove pre-existing dead code unless asked.
+
+The test: Every changed line should trace directly to the user's request.
+
+### Goal-Driven Execution
+
+**Define success criteria. Loop until verified.**
+
+Transform tasks into verifiable goals:
+- "Add validation" → "Write tests for invalid inputs, then make them pass"
+- "Fix the bug" → "Write a test that reproduces it, then make it pass"
+- "Refactor X" → "Ensure tests pass before and after"
+
+For multi-step tasks, state a brief plan:
+```
+1. [Step] → verify: [check]
+2. [Step] → verify: [check]
+3. [Step] → verify: [check]
+```
+
+Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.
+
+These guidelines are working if fewer unnecessary changes appear in diffs, fewer rewrites are needed due to overcomplication, and clarifying questions come before implementation rather than after mistakes.
diff --git a/backend-spring/.omc/state/last-tool-error.json b/backend-spring/.omc/state/last-tool-error.json
new file mode 100644
index 000000000..505c777ce
--- /dev/null
+++ b/backend-spring/.omc/state/last-tool-error.json
@@ -0,0 +1,7 @@
+{
+ "tool_name": "Bash",
+ "tool_input_preview": "{\"command\":\"cd backend-spring && ./mvnw test -Dtest=\\\"MonitoringServiceTest\\\\$GetDatabaseStatsTests\\\" -B 2>&1 | tail -20\",\"timeout\":120000,\"description\":\"Run getDatabaseStats tests with nested class\"}",
+ "error": "Exit code 1\n/bin/bash: 第 1 行：cd: backend-spring: 没有那个文件或目录",
+ "timestamp": "2026-04-18T11:39:41.008Z",
+ "retry_count": 1
+}
\ No newline at end of file
diff --git a/backend-spring/src/main/java/com/ulticode/modules/achievement/controller/AchievementController.java b/backend-spring/src/main/java/com/ulticode/modules/achievement/controller/AchievementController.java
index 382c8144d..19e709a17 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/achievement/controller/AchievementController.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/achievement/controller/AchievementController.java
@@ -53,6 +53,20 @@ public Result getCurrentUserPoints() {
return Result.success(achievementService.getUserPoints(userId));
}
+ // ========== Path Aliases for Frontend ==========
+
+ @Operation(summary = "Alias for /achievements/user/me - get current user's achievements")
+ @GetMapping("/my")
+ public Result> getCurrentUserAchievementsAlias() {
+ return getCurrentUserAchievements();
+ }
+
+ @Operation(summary = "Alias for /achievements/user/me/points - get current user's points")
+ @GetMapping("/points")
+ public Result getCurrentUserPointsAlias() {
+ return getCurrentUserPoints();
+ }
+
@Operation(summary = "Create achievement (admin only)")
@RateLimit(key = "achievement:create", limit = 30, period = 60)
@PostMapping
diff --git a/backend-spring/src/main/java/com/ulticode/modules/admin/controller/AdminContestController.java b/backend-spring/src/main/java/com/ulticode/modules/admin/controller/AdminContestController.java
index 869153b18..b3c693fde 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/admin/controller/AdminContestController.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/admin/controller/AdminContestController.java
@@ -2,16 +2,25 @@
import com.ulticode.common.response.PageResult;
import com.ulticode.common.response.Result;
+import com.ulticode.common.util.SecurityUtil;
import com.ulticode.modules.admin.dto.AdminContestQueryDTO;
import com.ulticode.modules.admin.dto.AdminContestVO;
import com.ulticode.modules.admin.service.AdminContestService;
+import com.ulticode.modules.contest.dto.CreateContestDTO;
+import com.ulticode.modules.contest.dto.UpdateContestDTO;
+import com.ulticode.modules.contest.entity.ContestAnnouncement;
+import com.ulticode.modules.contest.dto.CreateAnnouncementDTO;
+import com.ulticode.modules.contest.dto.UpdateAnnouncementDTO;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
+import java.util.List;
+
/**
* Admin controller for contest management.
*/
@@ -37,4 +46,79 @@ public Result> getContests(AdminContestQueryDTO query
public Result getContest(@PathVariable String id) {
return Result.success(adminContestService.getContest(id));
}
+
+ @Operation(summary = "Create contest")
+ @PostMapping
+ @PreAuthorize("hasAnyRole('ADMIN', 'SUPER_ADMIN')")
+ public Result createContest(@Valid @RequestBody CreateContestDTO dto) {
+ String userId = SecurityUtil.getCurrentUserId();
+ return Result.success(adminContestService.createContest(dto, userId));
+ }
+
+ @Operation(summary = "Update contest")
+ @PatchMapping("/{id}")
+ @PreAuthorize("hasAnyRole('ADMIN', 'SUPER_ADMIN')")
+ public Result updateContest(@PathVariable String id, @Valid @RequestBody UpdateContestDTO dto) {
+ return Result.success(adminContestService.updateContest(id, dto));
+ }
+
+ @Operation(summary = "Delete contest")
+ @DeleteMapping("/{id}")
+ @PreAuthorize("hasAnyRole('ADMIN', 'SUPER_ADMIN')")
+ public Result deleteContest(@PathVariable String id) {
+ adminContestService.deleteContest(id);
+ return Result.success(null);
+ }
+
+ @Operation(summary = "Start contest")
+ @PostMapping("/{id}/start")
+ @PreAuthorize("hasAnyRole('ADMIN', 'SUPER_ADMIN')")
+ public Result startContest(@PathVariable String id) {
+ return Result.success(adminContestService.startContest(id));
+ }
+
+ @Operation(summary = "End contest")
+ @PostMapping("/{id}/end")
+ @PreAuthorize("hasAnyRole('ADMIN', 'SUPER_ADMIN')")
+ public Result endContest(@PathVariable String id) {
+ return Result.success(adminContestService.endContest(id));
+ }
+
+ // Announcement CRUD
+
+ @Operation(summary = "Get contest announcements")
+ @GetMapping("/{id}/announcements")
+ @PreAuthorize("hasAnyRole('ADMIN', 'SUPER_ADMIN')")
+ public Result> getAnnouncements(@PathVariable String id) {
+ return Result.success(adminContestService.getAnnouncements(id));
+ }
+
+ @Operation(summary = "Create contest announcement")
+ @PostMapping("/{id}/announcements")
+ @PreAuthorize("hasAnyRole('ADMIN', 'SUPER_ADMIN')")
+ public Result createAnnouncement(
+ @PathVariable String id,
+ @Valid @RequestBody CreateAnnouncementDTO dto) {
+ return Result.success(adminContestService.createAnnouncement(id, dto.getTitle(), dto.getContent(), dto.getIsPinned()));
+ }
+
+ @Operation(summary = "Update contest announcement")
+ @PatchMapping("/{contestId}/announcements/{announcementId}")
+ @PreAuthorize("hasAnyRole('ADMIN', 'SUPER_ADMIN')")
+ public Result updateAnnouncement(
+ @PathVariable String contestId,
+ @PathVariable String announcementId,
+ @Valid @RequestBody UpdateAnnouncementDTO dto) {
+ return Result.success(adminContestService.updateAnnouncement(contestId, announcementId, dto.getTitle(), dto.getContent(), dto.getIsPinned()));
+ }
+
+ @Operation(summary = "Delete contest announcement")
+ @DeleteMapping("/{contestId}/announcements/{announcementId}")
+ @PreAuthorize("hasAnyRole('ADMIN', 'SUPER_ADMIN')")
+ public Result deleteAnnouncement(
+ @PathVariable String contestId,
+ @PathVariable String announcementId) {
+ adminContestService.deleteAnnouncement(contestId, announcementId);
+ return Result.success(null);
+ }
}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/admin/controller/AdminProblemController.java b/backend-spring/src/main/java/com/ulticode/modules/admin/controller/AdminProblemController.java
index 3f28e949f..77e2e4546 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/admin/controller/AdminProblemController.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/admin/controller/AdminProblemController.java
@@ -1,6 +1,8 @@
package com.ulticode.modules.admin.controller;
import jakarta.validation.Valid;
+
+import java.util.List;
import com.ulticode.common.annotation.RateLimit;
import com.ulticode.common.response.PageResult;
import com.ulticode.common.response.Result;
@@ -88,6 +90,14 @@ public Result unpublishProblem(@PathVariable Long id) {
return Result.success(problemService.unpublishProblem(id));
}
+ @Operation(summary = "Bulk problem action", description = "Perform bulk action on multiple problems (publish, unpublish, delete, edit)")
+ @RateLimit(key = "admin:problem-bulk", limit = 10, period = 60)
+ @PostMapping("/bulk")
+ @PreAuthorize("hasAnyRole('ADMIN', 'SUPER_ADMIN')")
+ public Result> bulkAction(@Valid @RequestBody BulkProblemRequestDTO request) {
+ return Result.success(adminProblemService.bulkAction(request));
+ }
+
// ========== Tab-specific Endpoints ==========
@Operation(summary = "Get problem header data", description = "Get header data for problem header tab")
diff --git a/backend-spring/src/main/java/com/ulticode/modules/admin/dto/problem/BulkProblemRequestDTO.java b/backend-spring/src/main/java/com/ulticode/modules/admin/dto/problem/BulkProblemRequestDTO.java
new file mode 100644
index 000000000..7c97c167f
--- /dev/null
+++ b/backend-spring/src/main/java/com/ulticode/modules/admin/dto/problem/BulkProblemRequestDTO.java
@@ -0,0 +1,38 @@
+package com.ulticode.modules.admin.dto.problem;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * DTO for bulk problem operations.
+ */
+@Data
+@Schema(description = "Bulk problem operation request")
+public class BulkProblemRequestDTO {
+
+ @NotEmpty(message = "IDs list cannot be empty")
+ @Schema(description = "List of problem IDs to operate on")
+ private List ids;
+
+ @NotNull(message = "Action is required")
+ @Schema(description = "Bulk action to perform", allowableValues = {"publish", "unpublish", "delete", "edit"})
+ private BulkAction action;
+
+ @Schema(description = "Optional parameters for edit action, e.g., { difficulty: \"Easy\" }")
+ private Map params;
+
+ /**
+ * Bulk action enum.
+ */
+ public enum BulkAction {
+ publish,
+ unpublish,
+ delete,
+ edit
+ }
+}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/admin/dto/problem/BulkProblemResultDTO.java b/backend-spring/src/main/java/com/ulticode/modules/admin/dto/problem/BulkProblemResultDTO.java
new file mode 100644
index 000000000..c888b016c
--- /dev/null
+++ b/backend-spring/src/main/java/com/ulticode/modules/admin/dto/problem/BulkProblemResultDTO.java
@@ -0,0 +1,25 @@
+package com.ulticode.modules.admin.dto.problem;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * DTO for bulk operation result per item.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Schema(description = "Bulk operation result for a single item")
+public class BulkProblemResultDTO {
+
+ @Schema(description = "Problem ID")
+ private String id;
+
+ @Schema(description = "Whether the operation succeeded")
+ private boolean success;
+
+ @Schema(description = "Error message if operation failed")
+ private String error;
+}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/admin/service/AdminContestService.java b/backend-spring/src/main/java/com/ulticode/modules/admin/service/AdminContestService.java
index 1af7dba68..46bed67b9 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/admin/service/AdminContestService.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/admin/service/AdminContestService.java
@@ -3,6 +3,11 @@
import com.ulticode.common.response.PageResult;
import com.ulticode.modules.admin.dto.AdminContestQueryDTO;
import com.ulticode.modules.admin.dto.AdminContestVO;
+import com.ulticode.modules.contest.dto.CreateContestDTO;
+import com.ulticode.modules.contest.dto.UpdateContestDTO;
+import com.ulticode.modules.contest.entity.ContestAnnouncement;
+
+import java.util.List;
/**
* Service interface for admin contest operations.
@@ -24,4 +29,86 @@ public interface AdminContestService {
* @return the contest VO
*/
AdminContestVO getContest(String id);
+
+ /**
+ * Create a new contest with optional problem assignment.
+ *
+ * @param dto the contest creation data
+ * @param userId the creating admin's user ID
+ * @return the created contest VO
+ */
+ AdminContestVO createContest(CreateContestDTO dto, String userId);
+
+ /**
+ * Update an existing contest (only UPCOMING status allowed).
+ *
+ * @param id the contest ID
+ * @param dto the update data
+ * @return the updated contest VO
+ */
+ AdminContestVO updateContest(String id, UpdateContestDTO dto);
+
+ /**
+ * Soft-delete a contest (UPCOMING or FINISHED only).
+ *
+ * @param id the contest ID
+ */
+ void deleteContest(String id);
+
+ /**
+ * Start a contest (UPCOMING -> RUNNING, requires at least one problem).
+ *
+ * @param id the contest ID
+ * @return the updated contest VO
+ */
+ AdminContestVO startContest(String id);
+
+ /**
+ * End a contest (RUNNING -> FINISHED).
+ *
+ * @param id the contest ID
+ * @return the updated contest VO
+ */
+ AdminContestVO endContest(String id);
+
+ // Announcement CRUD (D-11)
+
+ /**
+ * Create a contest announcement and push via WebSocket.
+ *
+ * @param contestId the contest ID
+ * @param title the announcement title
+ * @param content the announcement content
+ * @param isPinned whether to pin the announcement
+ * @return the created announcement
+ */
+ ContestAnnouncement createAnnouncement(String contestId, String title, String content, Boolean isPinned);
+
+ /**
+ * Update an existing contest announcement.
+ *
+ * @param contestId the contest ID
+ * @param announcementId the announcement ID
+ * @param title the new title (optional)
+ * @param content the new content (optional)
+ * @param isPinned the new pinned status (optional)
+ * @return the updated announcement
+ */
+ ContestAnnouncement updateAnnouncement(String contestId, String announcementId, String title, String content, Boolean isPinned);
+
+ /**
+ * Delete a contest announcement.
+ *
+ * @param contestId the contest ID
+ * @param announcementId the announcement ID
+ */
+ void deleteAnnouncement(String contestId, String announcementId);
+
+ /**
+ * Get all announcements for a contest, ordered by pinned status then creation time.
+ *
+ * @param contestId the contest ID
+ * @return list of announcements
+ */
+ List getAnnouncements(String contestId);
}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/admin/service/AdminProblemService.java b/backend-spring/src/main/java/com/ulticode/modules/admin/service/AdminProblemService.java
index 6f15081cb..d74499602 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/admin/service/AdminProblemService.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/admin/service/AdminProblemService.java
@@ -2,6 +2,8 @@
import com.ulticode.modules.admin.dto.problem.*;
+import java.util.List;
+
/**
* Admin service for problem management with tab-specific data.
*/
@@ -38,4 +40,12 @@ public interface AdminProblemService {
* @return Cases data with examples, constraints, and hints
*/
CasesDataVO getCasesData(Long id);
+
+ /**
+ * Perform bulk action on multiple problems.
+ *
+ * @param request Bulk operation request containing IDs and action
+ * @return List of results per problem ID
+ */
+ List bulkAction(BulkProblemRequestDTO request);
}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/admin/service/impl/AdminContestServiceImpl.java b/backend-spring/src/main/java/com/ulticode/modules/admin/service/impl/AdminContestServiceImpl.java
index fcb3da6c7..6d53ce62d 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/admin/service/impl/AdminContestServiceImpl.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/admin/service/impl/AdminContestServiceImpl.java
@@ -5,16 +5,31 @@
import com.ulticode.common.exception.BusinessException;
import com.ulticode.common.exception.ErrorCode;
import com.ulticode.common.response.PageResult;
+import com.ulticode.common.util.SecurityUtil;
import com.ulticode.modules.admin.dto.AdminContestQueryDTO;
import com.ulticode.modules.admin.dto.AdminContestVO;
import com.ulticode.modules.admin.service.AdminContestService;
+import com.ulticode.modules.contest.dto.CreateContestDTO;
+import com.ulticode.modules.contest.dto.UpdateContestDTO;
import com.ulticode.modules.contest.entity.Contest;
+import com.ulticode.modules.contest.entity.ContestAnnouncement;
+import com.ulticode.modules.contest.entity.ContestProblem;
+import com.ulticode.modules.contest.entity.enums.ContestStatus;
import com.ulticode.modules.contest.mapper.ContestMapper;
+import com.ulticode.modules.contest.mapper.ContestAnnouncementMapper;
+import com.ulticode.modules.contest.mapper.ContestProblemMapper;
+import com.ulticode.modules.websocket.service.RealtimeService;
+import com.ulticode.modules.websocket.contest.dto.AnnouncementPayload;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.UUID;
+
/**
* Implementation of AdminContestService.
*/
@@ -24,6 +39,9 @@
public class AdminContestServiceImpl implements AdminContestService {
private final ContestMapper contestMapper;
+ private final ContestProblemMapper contestProblemMapper;
+ private final ContestAnnouncementMapper contestAnnouncementMapper;
+ private final RealtimeService realtimeService;
@Override
public PageResult getContests(AdminContestQueryDTO query) {
@@ -84,6 +102,230 @@ public AdminContestVO getContest(String id) {
return toAdminVO(contest);
}
+ @Override
+ @Transactional
+ public AdminContestVO createContest(CreateContestDTO dto, String userId) {
+ Contest contest = new Contest();
+ contest.setTitle(dto.getTitle());
+ contest.setDescription(dto.getDescription());
+ contest.setStartTime(dto.getStartTime());
+ contest.setDurationMinutes(dto.getDuration());
+ contest.setEndTime(dto.getStartTime().plusMinutes(dto.getDuration()));
+ contest.setMaxParticipants(dto.getMaxParticipants());
+ contest.setIsVisible(dto.getIsPublished() != null ? dto.getIsPublished() : false);
+ contest.setCreatedBy(userId);
+ contest.setStatus(ContestStatus.UPCOMING.name());
+ contest.setRegisteredCount(0);
+ contest.setParticipantCount(0);
+ contest.setSubmissionCount(0);
+ contest.setIsDeleted(false);
+
+ String slug = generateSlug(dto.getTitle());
+ contest.setSlug(slug);
+
+ contestMapper.insert(contest);
+
+ // Bulk-insert contest problems if provided
+ List problemIds = dto.getProblemIds();
+ if (problemIds != null && !problemIds.isEmpty()) {
+ for (int i = 0; i < problemIds.size(); i++) {
+ ContestProblem cp = new ContestProblem();
+ cp.setContestId(contest.getId());
+ cp.setProblemId(problemIds.get(i));
+ cp.setProblemIndex("Q" + (i + 1));
+ cp.setScore(0);
+ cp.setBaseScore(100);
+ cp.setSolvedCount(0);
+ cp.setSubmissionCount(0);
+ contestProblemMapper.insert(cp);
+ }
+ }
+
+ log.info("Admin created contest: {} by user {}", contest.getId(), userId);
+ return toAdminVO(contest);
+ }
+
+ @Override
+ @Transactional
+ public AdminContestVO updateContest(String id, UpdateContestDTO dto) {
+ Contest contest = contestMapper.selectById(id);
+ if (contest == null) {
+ throw new BusinessException(ErrorCode.CONTEST_NOT_FOUND);
+ }
+
+ if (!ContestStatus.UPCOMING.name().equals(contest.getStatus())) {
+ throw new BusinessException(ErrorCode.CONTEST_ONLY_REGISTER_UPCOMING);
+ }
+
+ if (dto.getTitle() != null) {
+ contest.setTitle(dto.getTitle());
+ }
+ if (dto.getDescription() != null) {
+ contest.setDescription(dto.getDescription());
+ }
+ if (dto.getStartTime() != null) {
+ contest.setStartTime(dto.getStartTime());
+ }
+ if (dto.getDuration() != null) {
+ contest.setDurationMinutes(dto.getDuration());
+ contest.setEndTime(dto.getStartTime() != null
+ ? dto.getStartTime().plusMinutes(dto.getDuration())
+ : contest.getStartTime().plusMinutes(dto.getDuration()));
+ }
+ if (dto.getMaxParticipants() != null) {
+ contest.setMaxParticipants(dto.getMaxParticipants());
+ }
+ if (dto.getIsPublished() != null) {
+ contest.setIsVisible(dto.getIsPublished());
+ }
+
+ // Replace contest problems if problemIds is provided
+ if (dto.getProblemIds() != null) {
+ contestProblemMapper.deleteByContestId(id);
+ List problemIds = dto.getProblemIds();
+ for (int i = 0; i < problemIds.size(); i++) {
+ ContestProblem cp = new ContestProblem();
+ cp.setContestId(id);
+ cp.setProblemId(problemIds.get(i));
+ cp.setProblemIndex("Q" + (i + 1));
+ cp.setScore(0);
+ cp.setBaseScore(100);
+ cp.setSolvedCount(0);
+ cp.setSubmissionCount(0);
+ contestProblemMapper.insert(cp);
+ }
+ }
+
+ contestMapper.updateById(contest);
+
+ log.info("Admin updated contest: {}", id);
+ return toAdminVO(contest);
+ }
+
+ @Override
+ public void deleteContest(String id) {
+ Contest contest = contestMapper.selectById(id);
+ if (contest == null) {
+ throw new BusinessException(ErrorCode.CONTEST_NOT_FOUND);
+ }
+
+ String status = contest.getStatus();
+ if (!ContestStatus.UPCOMING.name().equals(status)
+ && !ContestStatus.FINISHED.name().equals(status)) {
+ throw new BusinessException(ErrorCode.CONTEST_NOT_FOUND);
+ }
+
+ contest.setIsDeleted(true);
+ contest.setDeletedAt(LocalDateTime.now());
+ contest.setDeletedBy(SecurityUtil.getCurrentUserId());
+ contestMapper.updateById(contest);
+
+ log.info("Admin deleted contest: {}", id);
+ }
+
+ @Override
+ public AdminContestVO startContest(String id) {
+ Contest contest = contestMapper.selectById(id);
+ if (contest == null) {
+ throw new BusinessException(ErrorCode.CONTEST_NOT_FOUND);
+ }
+
+ if (!ContestStatus.UPCOMING.name().equals(contest.getStatus())) {
+ throw new BusinessException(ErrorCode.CONTEST_NOT_STARTED);
+ }
+
+ long problemCount = contestProblemMapper.countByContestId(id);
+ if (problemCount == 0) {
+ throw new BusinessException(ErrorCode.CONTEST_NOT_FOUND);
+ }
+
+ contest.setStatus(ContestStatus.RUNNING.name());
+ contestMapper.updateById(contest);
+
+ log.info("Admin started contest: {}", id);
+ return toAdminVO(contest);
+ }
+
+ @Override
+ public AdminContestVO endContest(String id) {
+ Contest contest = contestMapper.selectById(id);
+ if (contest == null) {
+ throw new BusinessException(ErrorCode.CONTEST_NOT_FOUND);
+ }
+
+ if (!ContestStatus.RUNNING.name().equals(contest.getStatus())) {
+ throw new BusinessException(ErrorCode.CONTEST_ENDED);
+ }
+
+ contest.setStatus(ContestStatus.FINISHED.name());
+ contestMapper.updateById(contest);
+
+ log.info("Admin ended contest: {}", id);
+ return toAdminVO(contest);
+ }
+
+ @Override
+ public ContestAnnouncement createAnnouncement(String contestId, String title, String content, Boolean isPinned) {
+ Contest contest = contestMapper.selectById(contestId);
+ if (contest == null) {
+ throw new BusinessException(ErrorCode.CONTEST_NOT_FOUND);
+ }
+
+ ContestAnnouncement announcement = new ContestAnnouncement();
+ announcement.setContestId(contestId);
+ announcement.setTitle(title);
+ announcement.setContent(content);
+ announcement.setIsPinned(isPinned != null ? isPinned : false);
+
+ contestAnnouncementMapper.insert(announcement);
+
+ // WebSocket push (D-12)
+ realtimeService.emitAnnouncement(AnnouncementPayload.of(announcement.getId(), contestId, title, content));
+
+ log.info("Admin created announcement {} for contest {}", announcement.getId(), contestId);
+ return announcement;
+ }
+
+ @Override
+ public ContestAnnouncement updateAnnouncement(String contestId, String announcementId, String title, String content, Boolean isPinned) {
+ ContestAnnouncement announcement = contestAnnouncementMapper.findByContestIdAndId(contestId, announcementId);
+ if (announcement == null) {
+ throw new BusinessException(ErrorCode.BAD_REQUEST);
+ }
+
+ if (title != null) {
+ announcement.setTitle(title);
+ }
+ if (content != null) {
+ announcement.setContent(content);
+ }
+ if (isPinned != null) {
+ announcement.setIsPinned(isPinned);
+ }
+
+ contestAnnouncementMapper.updateById(announcement);
+
+ log.info("Admin updated announcement {} for contest {}", announcementId, contestId);
+ return announcement;
+ }
+
+ @Override
+ public void deleteAnnouncement(String contestId, String announcementId) {
+ ContestAnnouncement announcement = contestAnnouncementMapper.findByContestIdAndId(contestId, announcementId);
+ if (announcement == null) {
+ throw new BusinessException(ErrorCode.BAD_REQUEST);
+ }
+
+ contestAnnouncementMapper.deleteById(announcementId);
+
+ log.info("Admin deleted announcement {} for contest {}", announcementId, contestId);
+ }
+
+ @Override
+ public List getAnnouncements(String contestId) {
+ return contestAnnouncementMapper.findByContestIdOrderByCreatedAtDesc(contestId);
+ }
+
/**
* Convert Contest entity to AdminContestVO.
*/
@@ -106,7 +348,28 @@ private AdminContestVO toAdminVO(Contest contest) {
vo.setParticipantCount(contest.getParticipantCount());
vo.setCreatedAt(contest.getCreatedAt());
vo.setUpdatedAt(contest.getUpdatedAt());
+ vo.setProblemCount((int) contestProblemMapper.countByContestId(contest.getId()));
return vo;
}
+
+ /**
+ * Generate a URL-friendly slug from a title.
+ */
+ private String generateSlug(String title) {
+ if (title == null || title.isBlank()) {
+ return "contest-" + UUID.randomUUID().toString().substring(0, 8);
+ }
+ String slug = title.toLowerCase()
+ .replaceAll("[^a-z0-9\\s-]", "")
+ .replaceAll("\\s+", "-")
+ .replaceAll("-+", "-")
+ .replaceAll("^-|-$", "");
+
+ if (slug.length() < 3) {
+ slug = slug + "-" + UUID.randomUUID().toString().substring(0, 8);
+ }
+
+ return slug;
+ }
}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/admin/service/impl/AdminProblemServiceImpl.java b/backend-spring/src/main/java/com/ulticode/modules/admin/service/impl/AdminProblemServiceImpl.java
index 48b3f0daf..c1267fa97 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/admin/service/impl/AdminProblemServiceImpl.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/admin/service/impl/AdminProblemServiceImpl.java
@@ -14,6 +14,7 @@
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
@@ -34,6 +35,7 @@ public class AdminProblemServiceImpl implements AdminProblemService {
private final ProblemTagMapper problemTagMapper;
private final ProblemTagRelationMapper problemTagRelationMapper;
private final ObjectMapper objectMapper;
+ private final com.ulticode.modules.problem.service.ProblemService problemService;
@Override
public HeaderDataVO getHeaderData(Long id) {
@@ -142,6 +144,37 @@ public CasesDataVO getCasesData(Long id) {
return vo;
}
+ @Override
+ public List bulkAction(BulkProblemRequestDTO request) {
+ List results = new ArrayList<>();
+ for (String idStr : request.getIds()) {
+ try {
+ Long id = Long.parseLong(idStr);
+ switch (request.getAction()) {
+ case publish -> problemService.publishProblem(id);
+ case unpublish -> problemService.unpublishProblem(id);
+ case delete -> problemService.deleteProblem(id);
+ case edit -> {
+ var params = request.getParams();
+ if (params != null && params.containsKey("difficulty")) {
+ // Update difficulty via the Problem entity
+ Problem problem = problemMapper.selectById(id);
+ if (problem != null) {
+ problem.setDifficulty((String) params.get("difficulty"));
+ problemMapper.updateById(problem);
+ }
+ }
+ }
+ }
+ results.add(new BulkProblemResultDTO(idStr, true, null));
+ } catch (Exception e) {
+ log.error("Bulk action failed for problem id={}: {}", idStr, e.getMessage(), e);
+ results.add(new BulkProblemResultDTO(idStr, false, e.getMessage()));
+ }
+ }
+ return results;
+ }
+
// ========== Private Helper Methods ==========
private Problem findProblemById(Long id) {
diff --git a/backend-spring/src/main/java/com/ulticode/modules/contest/dto/CreateAnnouncementDTO.java b/backend-spring/src/main/java/com/ulticode/modules/contest/dto/CreateAnnouncementDTO.java
new file mode 100644
index 000000000..c47330083
--- /dev/null
+++ b/backend-spring/src/main/java/com/ulticode/modules/contest/dto/CreateAnnouncementDTO.java
@@ -0,0 +1,20 @@
+package com.ulticode.modules.contest.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+
+/**
+ * DTO for creating a contest announcement.
+ */
+@Data
+public class CreateAnnouncementDTO {
+ @NotBlank(message = "Title is required")
+ @Size(max = 200, message = "Title must not exceed 200 characters")
+ private String title;
+
+ @NotBlank(message = "Content is required")
+ private String content;
+
+ private Boolean isPinned;
+}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/contest/dto/UpdateAnnouncementDTO.java b/backend-spring/src/main/java/com/ulticode/modules/contest/dto/UpdateAnnouncementDTO.java
new file mode 100644
index 000000000..93e84ddf6
--- /dev/null
+++ b/backend-spring/src/main/java/com/ulticode/modules/contest/dto/UpdateAnnouncementDTO.java
@@ -0,0 +1,18 @@
+package com.ulticode.modules.contest.dto;
+
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+
+/**
+ * DTO for updating a contest announcement.
+ * All fields are optional for PATCH semantics.
+ */
+@Data
+public class UpdateAnnouncementDTO {
+ @Size(max = 200, message = "Title must not exceed 200 characters")
+ private String title;
+
+ private String content;
+
+ private Boolean isPinned;
+}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/contest/entity/Contest.java b/backend-spring/src/main/java/com/ulticode/modules/contest/entity/Contest.java
index d5f63b7b1..710bbf37f 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/contest/entity/Contest.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/contest/entity/Contest.java
@@ -28,6 +28,10 @@ public class Contest {
private LocalDateTime endTime;
+ private LocalDateTime actualStartTime;
+
+ private LocalDateTime actualEndTime;
+
private Integer durationMinutes;
private LocalDateTime registrationStart;
diff --git a/backend-spring/src/main/java/com/ulticode/modules/contest/entity/ContestAnnouncement.java b/backend-spring/src/main/java/com/ulticode/modules/contest/entity/ContestAnnouncement.java
new file mode 100644
index 000000000..2a283b66d
--- /dev/null
+++ b/backend-spring/src/main/java/com/ulticode/modules/contest/entity/ContestAnnouncement.java
@@ -0,0 +1,29 @@
+package com.ulticode.modules.contest.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * Contest announcement entity - announcements within a contest.
+ * Note: No updatedAt field (V3 table has no updated_at column).
+ */
+@Data
+@TableName("contest_announcements")
+public class ContestAnnouncement {
+
+ @TableId(type = IdType.ASSIGN_UUID)
+ private String id;
+
+ private String contestId;
+
+ private String title;
+
+ private String content;
+
+ @TableField(fill = FieldFill.INSERT)
+ private LocalDateTime createdAt;
+
+ private Boolean isPinned;
+}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/contest/entity/ContestParticipant.java b/backend-spring/src/main/java/com/ulticode/modules/contest/entity/ContestParticipant.java
index 5720c42a2..4bb722265 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/contest/entity/ContestParticipant.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/contest/entity/ContestParticipant.java
@@ -20,7 +20,7 @@ public class ContestParticipant {
private String userId;
/**
- * Participant status: REGISTERED, PARTICIPATING, COMPLETED, DISQUALIFIED
+ * Participant status: REGISTERED, STARTED, FINISHED, DISQUALIFIED
*/
private String status;
diff --git a/backend-spring/src/main/java/com/ulticode/modules/contest/entity/ContestProblem.java b/backend-spring/src/main/java/com/ulticode/modules/contest/entity/ContestProblem.java
new file mode 100644
index 000000000..8c6d9bea9
--- /dev/null
+++ b/backend-spring/src/main/java/com/ulticode/modules/contest/entity/ContestProblem.java
@@ -0,0 +1,46 @@
+package com.ulticode.modules.contest.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * Contest problem entity - maps problems to contests.
+ */
+@Data
+@TableName("contest_problems")
+public class ContestProblem {
+
+ @TableId(type = IdType.ASSIGN_UUID)
+ private String id;
+
+ private String contestId;
+
+ /**
+ * Problem ID (bigint in DB).
+ */
+ private Long problemId;
+
+ private String problemIndex;
+
+ private Integer score;
+
+ private Integer penaltyPerWrong;
+
+ private Integer solvedCount;
+
+ private Integer submissionCount;
+
+ private String label;
+
+ private Integer baseScore;
+
+ private Integer timeBonus;
+
+ @TableField(fill = FieldFill.INSERT)
+ private LocalDateTime createdAt;
+
+ @TableField(fill = FieldFill.INSERT_UPDATE)
+ private LocalDateTime updatedAt;
+}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/contest/entity/ContestSubmission.java b/backend-spring/src/main/java/com/ulticode/modules/contest/entity/ContestSubmission.java
new file mode 100644
index 000000000..ee021bf20
--- /dev/null
+++ b/backend-spring/src/main/java/com/ulticode/modules/contest/entity/ContestSubmission.java
@@ -0,0 +1,37 @@
+package com.ulticode.modules.contest.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * Contest submission entity - tracks submissions made during a contest.
+ * Note: No updatedAt field (V3 table has no updated_at column).
+ */
+@Data
+@TableName("contest_submissions")
+public class ContestSubmission {
+
+ @TableId(type = IdType.ASSIGN_UUID)
+ private String id;
+
+ private String submissionId;
+
+ private String contestId;
+
+ private String contestProblemId;
+
+ private String participantId;
+
+ private String virtualSessionId;
+
+ private LocalDateTime submittedAt;
+
+ private Integer timeFromStart;
+
+ private Boolean isAccepted;
+
+ @TableField(fill = FieldFill.INSERT)
+ private LocalDateTime createdAt;
+}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/contest/entity/enums/ContestParticipantStatus.java b/backend-spring/src/main/java/com/ulticode/modules/contest/entity/enums/ContestParticipantStatus.java
index b81d37393..82eb551c5 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/contest/entity/enums/ContestParticipantStatus.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/contest/entity/enums/ContestParticipantStatus.java
@@ -5,7 +5,7 @@
*/
public enum ContestParticipantStatus {
REGISTERED,
- PARTICIPATING,
- COMPLETED,
+ STARTED,
+ FINISHED,
DISQUALIFIED
}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/contest/mapper/ContestAnnouncementMapper.java b/backend-spring/src/main/java/com/ulticode/modules/contest/mapper/ContestAnnouncementMapper.java
new file mode 100644
index 000000000..14a3cef3a
--- /dev/null
+++ b/backend-spring/src/main/java/com/ulticode/modules/contest/mapper/ContestAnnouncementMapper.java
@@ -0,0 +1,25 @@
+package com.ulticode.modules.contest.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.ulticode.modules.contest.entity.ContestAnnouncement;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+import java.util.List;
+
+/**
+ * MyBatis-Plus mapper for ContestAnnouncement entity.
+ */
+@Mapper
+public interface ContestAnnouncementMapper extends BaseMapper {
+
+ @Select("SELECT * FROM contest_announcements WHERE contest_id = #{contestId} ORDER BY is_pinned DESC, created_at DESC")
+ List findByContestIdOrderByCreatedAtDesc(@Param("contestId") String contestId);
+
+ @Select("SELECT * FROM contest_announcements WHERE contest_id = #{contestId} AND id = #{id} LIMIT 1")
+ ContestAnnouncement findByContestIdAndId(
+ @Param("contestId") String contestId,
+ @Param("id") String id
+ );
+}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/contest/mapper/ContestParticipantMapper.java b/backend-spring/src/main/java/com/ulticode/modules/contest/mapper/ContestParticipantMapper.java
index 66dcb1717..e0b1b5644 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/contest/mapper/ContestParticipantMapper.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/contest/mapper/ContestParticipantMapper.java
@@ -103,7 +103,7 @@ boolean existsByContestIdAndUserId(
* @param limit maximum number of participants to return
* @return list of top participants
*/
- @Select("SELECT * FROM contest_participants WHERE contest_id = #{contestId} AND status = 'COMPLETED' ORDER BY total_score DESC, total_penalty ASC LIMIT #{limit}")
+ @Select("SELECT * FROM contest_participants WHERE contest_id = #{contestId} AND status = 'FINISHED' ORDER BY total_score DESC, total_penalty ASC LIMIT #{limit}")
List findTopParticipants(
@Param("contestId") String contestId,
@Param("limit") int limit
diff --git a/backend-spring/src/main/java/com/ulticode/modules/contest/mapper/ContestProblemMapper.java b/backend-spring/src/main/java/com/ulticode/modules/contest/mapper/ContestProblemMapper.java
new file mode 100644
index 000000000..74666f7bf
--- /dev/null
+++ b/backend-spring/src/main/java/com/ulticode/modules/contest/mapper/ContestProblemMapper.java
@@ -0,0 +1,35 @@
+package com.ulticode.modules.contest.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.ulticode.modules.contest.entity.ContestProblem;
+import org.apache.ibatis.annotations.Delete;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+import java.util.List;
+
+/**
+ * MyBatis-Plus mapper for ContestProblem entity.
+ */
+@Mapper
+public interface ContestProblemMapper extends BaseMapper {
+
+ @Select("SELECT * FROM contest_problems WHERE contest_id = #{contestId} ORDER BY problem_index ASC")
+ List findByContestId(@Param("contestId") String contestId);
+
+ @Select("SELECT * FROM contest_problems WHERE contest_id = #{contestId} AND problem_id = #{problemId} LIMIT 1")
+ ContestProblem findByContestIdAndProblemId(
+ @Param("contestId") String contestId,
+ @Param("problemId") Long problemId
+ );
+
+ @Select("SELECT COUNT(*) FROM contest_problems WHERE contest_id = #{contestId}")
+ long countByContestId(@Param("contestId") String contestId);
+
+ @Delete("DELETE FROM contest_problems WHERE contest_id = #{contestId}")
+ int deleteByContestId(@Param("contestId") String contestId);
+
+ @Select("SELECT * FROM contest_problems WHERE problem_id = #{problemId}")
+ List findByProblemId(@Param("problemId") Long problemId);
+}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/contest/mapper/ContestSubmissionMapper.java b/backend-spring/src/main/java/com/ulticode/modules/contest/mapper/ContestSubmissionMapper.java
new file mode 100644
index 000000000..53a02e255
--- /dev/null
+++ b/backend-spring/src/main/java/com/ulticode/modules/contest/mapper/ContestSubmissionMapper.java
@@ -0,0 +1,25 @@
+package com.ulticode.modules.contest.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.ulticode.modules.contest.entity.ContestSubmission;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+import java.util.List;
+
+/**
+ * MyBatis-Plus mapper for ContestSubmission entity.
+ */
+@Mapper
+public interface ContestSubmissionMapper extends BaseMapper {
+
+ @Select("SELECT * FROM contest_submissions WHERE contest_id = #{contestId} AND participant_id = #{participantId} ORDER BY submitted_at ASC")
+ List findByContestIdAndParticipantId(
+ @Param("contestId") String contestId,
+ @Param("participantId") String participantId
+ );
+
+ @Select("SELECT COUNT(*) FROM contest_submissions WHERE contest_id = #{contestId}")
+ long countByContestId(@Param("contestId") String contestId);
+}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/contest/scheduler/ContestScheduler.java b/backend-spring/src/main/java/com/ulticode/modules/contest/scheduler/ContestScheduler.java
new file mode 100644
index 000000000..0ee567329
--- /dev/null
+++ b/backend-spring/src/main/java/com/ulticode/modules/contest/scheduler/ContestScheduler.java
@@ -0,0 +1,110 @@
+package com.ulticode.modules.contest.scheduler;
+
+import com.ulticode.modules.contest.entity.Contest;
+import com.ulticode.modules.contest.mapper.ContestMapper;
+import com.ulticode.modules.contest.service.RatingCalculationService;
+import com.ulticode.modules.websocket.event.ContestStatusEvent.ContestStatus;
+import com.ulticode.modules.websocket.service.RealtimeService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * Scheduler for contest lifecycle transitions.
+ * Polls every 10 seconds to transition UPCOMING->RUNNING and RUNNING->FINISHED.
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class ContestScheduler {
+
+ private final ContestMapper contestMapper;
+ private final RealtimeService realtimeService;
+ private final RatingCalculationService ratingService;
+
+ @Scheduled(fixedRate = 10_000)
+ public void run() {
+ // Step 1: Find UPCOMING contests and transition those past start_time
+ List upcoming = contestMapper.findByStatus(
+ com.ulticode.modules.contest.entity.enums.ContestStatus.UPCOMING.name());
+ LocalDateTime now = LocalDateTime.now();
+ for (Contest contest : upcoming) {
+ if (contest.getStartTime() != null && !contest.getStartTime().isAfter(now)) {
+ transitionToRunning(contest);
+ }
+ }
+
+ // Step 2: Find RUNNING contests and transition those past end_time
+ List running = contestMapper.findByStatus(
+ com.ulticode.modules.contest.entity.enums.ContestStatus.RUNNING.name());
+ for (Contest contest : running) {
+ LocalDateTime effectiveEndTime = computeEffectiveEndTime(contest);
+ if (effectiveEndTime != null && !effectiveEndTime.isAfter(now)) {
+ transitionToFinished(contest);
+ }
+ }
+ }
+
+ private LocalDateTime computeEffectiveEndTime(Contest contest) {
+ if (contest.getEndTime() != null) {
+ return contest.getEndTime();
+ }
+ // Fallback: start_time + duration_minutes
+ if (contest.getStartTime() != null && contest.getDurationMinutes() != null) {
+ return contest.getStartTime().plusMinutes(contest.getDurationMinutes());
+ }
+ return null;
+ }
+
+ void transitionToRunning(Contest contest) {
+ // Re-check: skip if already RUNNING (idempotent)
+ if (com.ulticode.modules.contest.entity.enums.ContestStatus.RUNNING.name().equals(contest.getStatus())) {
+ return;
+ }
+ contest.setStatus(com.ulticode.modules.contest.entity.enums.ContestStatus.RUNNING.name());
+ contest.setActualStartTime(LocalDateTime.now());
+ contestMapper.updateById(contest);
+
+ // Emit WebSocket status
+ realtimeService.emitContestStatus(
+ contest.getId(),
+ ContestStatus.RUNNING,
+ contest.getActualStartTime() != null ? contest.getActualStartTime().atZone(java.time.ZoneId.systemDefault()).toInstant() : null,
+ null,
+ null
+ );
+
+ // Mark dirty so initial ranking appears on leaderboard
+ realtimeService.markDirty(contest.getId());
+
+ log.info("Contest {} transitioned to RUNNING", contest.getId());
+ }
+
+ void transitionToFinished(Contest contest) {
+ // Re-check: skip if already FINISHED (idempotent)
+ if (com.ulticode.modules.contest.entity.enums.ContestStatus.FINISHED.name().equals(contest.getStatus())) {
+ return;
+ }
+ contest.setStatus(com.ulticode.modules.contest.entity.enums.ContestStatus.FINISHED.name());
+ contest.setActualEndTime(LocalDateTime.now());
+ contestMapper.updateById(contest);
+
+ // Emit WebSocket status
+ realtimeService.emitContestStatus(
+ contest.getId(),
+ ContestStatus.ENDED,
+ null,
+ contest.getActualEndTime() != null ? contest.getActualEndTime().atZone(java.time.ZoneId.systemDefault()).toInstant() : null,
+ null
+ );
+
+ // Trigger rating calculation
+ ratingService.calculateAndUpdate(contest.getId());
+
+ log.info("Contest {} transitioned to FINISHED, ratings calculated", contest.getId());
+ }
+}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/contest/service/RatingCalculationService.java b/backend-spring/src/main/java/com/ulticode/modules/contest/service/RatingCalculationService.java
new file mode 100644
index 000000000..dc8c85ca3
--- /dev/null
+++ b/backend-spring/src/main/java/com/ulticode/modules/contest/service/RatingCalculationService.java
@@ -0,0 +1,15 @@
+package com.ulticode.modules.contest.service;
+
+/**
+ * Service for calculating Codeforces-style Elo ratings after contest completion.
+ */
+public interface RatingCalculationService {
+
+ /**
+ * Calculate and update ratings for all participants in a contest.
+ * Updates global_rankings table and contest_participants.final_rank.
+ *
+ * @param contestId the contest ID
+ */
+ void calculateAndUpdate(String contestId);
+}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/contest/service/impl/ContestServiceImpl.java b/backend-spring/src/main/java/com/ulticode/modules/contest/service/impl/ContestServiceImpl.java
index d87a475ad..891609467 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/contest/service/impl/ContestServiceImpl.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/contest/service/impl/ContestServiceImpl.java
@@ -409,8 +409,8 @@ public ParticipationStatusDTO getParticipationStatus(String contestId, String us
status.setRanking(participant.getFinalRank());
status.setScore(participant.getTotalScore() != null ? participant.getTotalScore().longValue() : null);
status.setHasStarted(participant.getStartedAt() != null);
- status.setIsCompleted(ContestParticipantStatus.COMPLETED.name().equals(participant.getStatus()));
- status.setIsActive(ContestParticipantStatus.PARTICIPATING.name().equals(participant.getStatus()));
+ status.setIsCompleted(ContestParticipantStatus.FINISHED.name().equals(participant.getStatus()));
+ status.setIsActive(ContestParticipantStatus.STARTED.name().equals(participant.getStatus()));
return status;
}
@@ -433,8 +433,8 @@ public List getUserContests(String userId, String type) {
case "participated":
default:
participants = participantMapper.findByUserId(userId).stream()
- .filter(p -> ContestParticipantStatus.COMPLETED.name().equals(p.getStatus()) ||
- ContestParticipantStatus.PARTICIPATING.name().equals(p.getStatus()))
+ .filter(p -> ContestParticipantStatus.FINISHED.name().equals(p.getStatus()) ||
+ ContestParticipantStatus.STARTED.name().equals(p.getStatus()))
.collect(Collectors.toList());
break;
}
@@ -476,7 +476,7 @@ public ParticipationStatusDTO startVirtualContest(String contestId, String userI
ContestParticipant participant = new ContestParticipant();
participant.setContestId(contestId);
participant.setUserId(userId);
- participant.setStatus(ContestParticipantStatus.PARTICIPATING.name());
+ participant.setStatus(ContestParticipantStatus.STARTED.name());
participant.setRegisteredAt(now);
participant.setStartedAt(now);
participant.setIsVirtual(true);
@@ -509,8 +509,8 @@ public ParticipationStatusDTO getVirtualSession(String contestId, String userId)
status.setStartTime(participant.getStartedAt());
status.setEndTime(participant.getStartedAt().plusMinutes(contest.getDurationMinutes()));
status.setHasStarted(true);
- status.setIsActive(ContestParticipantStatus.PARTICIPATING.name().equals(participant.getStatus()));
- status.setIsCompleted(ContestParticipantStatus.COMPLETED.name().equals(participant.getStatus()));
+ status.setIsActive(ContestParticipantStatus.STARTED.name().equals(participant.getStatus()));
+ status.setIsCompleted(ContestParticipantStatus.FINISHED.name().equals(participant.getStatus()));
return status;
}
@@ -534,7 +534,7 @@ public void finishVirtualContest(String contestId, String sessionId, String user
throw new BusinessException(ErrorCode.BAD_REQUEST);
}
- participant.setStatus(ContestParticipantStatus.COMPLETED.name());
+ participant.setStatus(ContestParticipantStatus.FINISHED.name());
participant.setFinishedAt(LocalDateTime.now());
participantMapper.updateById(participant);
diff --git a/backend-spring/src/main/java/com/ulticode/modules/contest/service/impl/RatingCalculationServiceImpl.java b/backend-spring/src/main/java/com/ulticode/modules/contest/service/impl/RatingCalculationServiceImpl.java
new file mode 100644
index 000000000..954606bfd
--- /dev/null
+++ b/backend-spring/src/main/java/com/ulticode/modules/contest/service/impl/RatingCalculationServiceImpl.java
@@ -0,0 +1,159 @@
+package com.ulticode.modules.contest.service.impl;
+
+import com.ulticode.modules.contest.entity.ContestParticipant;
+import com.ulticode.modules.contest.entity.GlobalRanking;
+import com.ulticode.modules.contest.entity.enums.RatingTitle;
+import com.ulticode.modules.contest.mapper.ContestParticipantMapper;
+import com.ulticode.modules.contest.mapper.GlobalRankingMapper;
+import com.ulticode.modules.contest.service.RatingCalculationService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Codeforces-style Elo rating calculation implementation.
+ * Updates global_rankings and contest_participants.final_rank after contest ends.
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class RatingCalculationServiceImpl implements RatingCalculationService {
+
+ private final ContestParticipantMapper participantMapper;
+ private final GlobalRankingMapper globalRankingMapper;
+
+ @Override
+ @Transactional
+ public void calculateAndUpdate(String contestId) {
+ // 1. Fetch all STARTED participants for this contest
+ List participants = participantMapper.findByContestIdAndStatus(
+ contestId, "STARTED");
+ if (participants.isEmpty()) {
+ log.info("No participants to rate for contest {}", contestId);
+ return;
+ }
+
+ // 2. Sort by score (DESC) then penalty (ASC) to determine rank
+ participants.sort((a, b) -> {
+ int scoreCmp = Double.compare(
+ b.getTotalScore() != null ? b.getTotalScore() : 0,
+ a.getTotalScore() != null ? a.getTotalScore() : 0);
+ if (scoreCmp != 0) return scoreCmp;
+ return Integer.compare(
+ a.getTotalPenalty() != null ? a.getTotalPenalty() : 0,
+ b.getTotalPenalty() != null ? b.getTotalPenalty() : 0);
+ });
+
+ // 3. Assign final_rank (1-based)
+ for (int i = 0; i < participants.size(); i++) {
+ ContestParticipant p = participants.get(i);
+ p.setFinalRank(i + 1);
+ participantMapper.updateById(p);
+ }
+
+ // 4. Calculate and update ratings (CF Elo variant)
+ // Only rate participants who have a global_ranking record (D-11)
+ for (ContestParticipant participant : participants) {
+ String userId = participant.getUserId();
+ Optional grOpt = globalRankingMapper.findByUserId(userId);
+ if (grOpt.isEmpty()) {
+ // D-11: Skip users without global_ranking record
+ log.debug("Skipping rating for user {} -- no global_ranking record", userId);
+ continue;
+ }
+ GlobalRanking gr = grOpt.get();
+ int oldRating = gr.getRating() != null ? gr.getRating() : 1500;
+
+ // Compute rating change using CF algorithm against all other participants
+ int newRating = calculateNewRating(oldRating, participants, participant);
+
+ // Determine title from new rating
+ RatingTitle newTitle = fromRating(newRating);
+
+ // Update global_ranking
+ globalRankingMapper.updateRating(userId, newRating, newTitle.name(), contestId);
+
+ // Update max rating title if new max achieved
+ if (newRating > gr.getMaxRating()) {
+ globalRankingMapper.updateMaxRatingTitle(newTitle.name(), userId);
+ }
+
+ log.debug("User {} rating: {} -> {} (title: {})", userId, oldRating, newRating, newTitle);
+ }
+
+ // 5. Recalculate global ranks (global_rank column)
+ globalRankingMapper.recalculateGlobalRanks();
+
+ log.info("Rating calculation complete for contest {}: {} participants rated", contestId, participants.size());
+ }
+
+ private int calculateNewRating(int myRating, List allParticipants,
+ ContestParticipant me) {
+ double totalExpected = 0.0;
+ double totalActual = 0.0;
+
+ for (ContestParticipant opponent : allParticipants) {
+ if (opponent.getUserId().equals(me.getUserId())) continue;
+
+ Optional oppGr = globalRankingMapper.findByUserId(opponent.getUserId());
+ if (oppGr.isEmpty()) continue;
+
+ int oppRating = oppGr.get().getRating() != null ? oppGr.get().getRating() : 1500;
+ double expected = 1.0 / (1.0 + Math.pow(10, (oppRating - myRating) / 400.0));
+ totalExpected += expected;
+
+ // Actual score: 1 if me.rank < opponent.rank (placed higher), 0 otherwise
+ int myRank = me.getFinalRank() != null ? me.getFinalRank() : Integer.MAX_VALUE;
+ int oppRank = opponent.getFinalRank() != null ? opponent.getFinalRank() : Integer.MAX_VALUE;
+ double actual = myRank < oppRank ? 1.0 : 0.0;
+ totalActual += actual;
+ }
+
+ int opponentCount = allParticipants.size() - 1;
+ if (opponentCount <= 0) {
+ return myRating;
+ }
+
+ int k = determineKFactor(myRating);
+ int change = (int) Math.round(k * (totalActual - totalExpected));
+ return Math.max(0, Math.min(3500, myRating + change));
+ }
+
+ private int determineKFactor(int rating) {
+ if (rating < 2100) {
+ return 32;
+ } else if (rating < 2400) {
+ return 24;
+ } else {
+ return 16;
+ }
+ }
+
+ static RatingTitle fromRating(int rating) {
+ if (rating < 1200) {
+ return RatingTitle.NEWBIE;
+ } else if (rating < 1400) {
+ return RatingTitle.PUPIL;
+ } else if (rating < 1600) {
+ return RatingTitle.SPECIALIST;
+ } else if (rating < 1900) {
+ return RatingTitle.EXPERT;
+ } else if (rating < 2100) {
+ return RatingTitle.CANDIDATE_MASTER;
+ } else if (rating < 2300) {
+ return RatingTitle.MASTER;
+ } else if (rating < 2400) {
+ return RatingTitle.INTERNATIONAL_MASTER;
+ } else if (rating < 2600) {
+ return RatingTitle.GRANDMASTER;
+ } else if (rating < 3000) {
+ return RatingTitle.INTERNATIONAL_GRANDMASTER;
+ } else {
+ return RatingTitle.LEGENDARY_GRANDMASTER;
+ }
+ }
+}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/problem/controller/ProblemController.java b/backend-spring/src/main/java/com/ulticode/modules/problem/controller/ProblemController.java
index 322aae338..5eb15f59d 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/problem/controller/ProblemController.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/problem/controller/ProblemController.java
@@ -113,6 +113,18 @@ public Result getAdjacentProblems(
return Result.success(adjacent);
}
+ /**
+ * Get a random published problem.
+ * Public endpoint - accessible without authentication.
+ *
+ * @return a random published problem
+ */
+ @Operation(summary = "Get a random published problem")
+ @GetMapping("/random")
+ public Result getRandomProblem() {
+ return Result.success(problemService.findRandomPublished());
+ }
+
/**
* Create a new problem.
* Admin only - requires ADMIN or SUPER_ADMIN role.
diff --git a/backend-spring/src/main/java/com/ulticode/modules/problem/dto/CreateProblemDTO.java b/backend-spring/src/main/java/com/ulticode/modules/problem/dto/CreateProblemDTO.java
index 3607f402e..669dce359 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/problem/dto/CreateProblemDTO.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/problem/dto/CreateProblemDTO.java
@@ -7,6 +7,8 @@
import jakarta.validation.constraints.Size;
import lombok.Data;
+import java.util.List;
+
/**
* DTO for creating a new problem.
*/
@@ -35,4 +37,25 @@ public class CreateProblemDTO {
@Schema(description = "Whether the problem is published", example = "true")
private Boolean isPublished;
+
+ @Schema(description = "Problem summary")
+ private String summary;
+
+ @Schema(description = "Problem content (markdown)")
+ private String content;
+
+ @Schema(description = "Examples as JSON array", example = "[{\"input\":\"...\", \"output\":\"...\", \"explanation\":\"...\"}]")
+ private String examples;
+
+ @Schema(description = "Constraints")
+ private String constraints;
+
+ @Schema(description = "Hints as JSON array", example = "[\"hint1\", \"hint2\"]")
+ private String hints;
+
+ @Schema(description = "Supported languages as JSON array", example = "[\"javascript\", \"python\", \"java\", \"c\", \"cpp\"]")
+ private List languages;
+
+ @Schema(description = "Tags as JSON array", example = "[\"array\", \"dynamic-programming\"]")
+ private List tags;
}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/problem/dto/ProblemVO.java b/backend-spring/src/main/java/com/ulticode/modules/problem/dto/ProblemVO.java
index b71fca43c..6a51d0ad2 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/problem/dto/ProblemVO.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/problem/dto/ProblemVO.java
@@ -2,6 +2,7 @@
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
+import com.ulticode.modules.problem.entity.Problem;
import lombok.Data;
import java.math.BigDecimal;
@@ -173,6 +174,59 @@ public class ProblemVO {
@JsonProperty("updated_at")
private LocalDateTime updatedAt;
+ /**
+ * Create a ProblemVO from a Problem entity.
+ *
+ * @param problem the problem entity
+ * @return the problem view object
+ */
+ public static ProblemVO from(Problem problem) {
+ if (problem == null) {
+ return null;
+ }
+ ProblemVO vo = new ProblemVO();
+ vo.setId(problem.getId());
+ vo.setSlug(problem.getSlug());
+ vo.setTitle(problem.getTitle());
+ vo.setDifficulty(problem.getDifficulty() != null ? problem.getDifficulty().toUpperCase() : null);
+ vo.setAcceptanceRate(problem.getAcceptanceRate());
+ vo.setStatus(problem.getStatus());
+ vo.setIsPremium(problem.getIsPremium());
+ vo.setHasSolution(problem.getHasSolution());
+ vo.setIsPublished(problem.getIsPublished());
+ vo.setPublishedAt(problem.getPublishedAt());
+ vo.setPublishedBy(problem.getPublishedBy());
+ vo.setIsDeleted(problem.getIsDeleted());
+ vo.setDeletedAt(problem.getDeletedAt());
+ vo.setIsFlagged(problem.getIsFlagged());
+ vo.setFlagReason(problem.getFlagReason());
+ vo.setFlagReportedBy(problem.getFlagReportedBy());
+ vo.setFlagReportedAt(problem.getFlagReportedAt());
+ vo.setFlagStatus(problem.getFlagStatus());
+ vo.setFlagReviewedBy(problem.getFlagReviewedBy());
+ vo.setFlagReviewedAt(problem.getFlagReviewedAt());
+ vo.setFlagNotes(problem.getFlagNotes());
+ vo.setCreatedAt(problem.getCreatedAt());
+ vo.setUpdatedAt(problem.getUpdatedAt());
+ vo.setSubmissionCount(0L);
+ vo.setSolutionCount(0L);
+ vo.setTags(List.of());
+ return vo;
+ }
+
+ /**
+ * Create a ProblemVO from a Problem entity with acceptance rate override.
+ *
+ * @param problem the problem entity
+ * @param acceptanceRate the acceptance rate to set (overrides entity value)
+ * @return the problem view object
+ */
+ public static ProblemVO from(Problem problem, BigDecimal acceptanceRate) {
+ ProblemVO vo = from(problem);
+ vo.setAcceptanceRate(acceptanceRate);
+ return vo;
+ }
+
/**
* Inner class for tag information in problem list
*/
diff --git a/backend-spring/src/main/java/com/ulticode/modules/problem/service/ProblemService.java b/backend-spring/src/main/java/com/ulticode/modules/problem/service/ProblemService.java
index 24870073a..552ae2424 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/problem/service/ProblemService.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/problem/service/ProblemService.java
@@ -127,4 +127,12 @@ public interface ProblemService {
* @return the adjacent problems response with prev and next problem IDs (slugs)
*/
AdjacentProblemsVO getAdjacentProblems(Long id);
+
+ /**
+ * Get a random published problem.
+ *
+ * @return a random published problem view object
+ * @throws BusinessException if no published problems are available
+ */
+ ProblemVO findRandomPublished();
}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/problem/service/impl/ProblemServiceImpl.java b/backend-spring/src/main/java/com/ulticode/modules/problem/service/impl/ProblemServiceImpl.java
index c044f944d..8745fd5b4 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/problem/service/impl/ProblemServiceImpl.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/problem/service/impl/ProblemServiceImpl.java
@@ -502,4 +502,16 @@ public AdjacentProblemsVO getAdjacentProblems(Long id) {
nextProblem != null ? nextProblem.getSlug() : null
);
}
+
+ @Override
+ public ProblemVO findRandomPublished() {
+ LambdaQueryWrapper wrapper = new LambdaQueryWrapper()
+ .eq(Problem::getIsPublished, true)
+ .last("ORDER BY RAND() LIMIT 1");
+ Problem problem = problemMapper.selectOne(wrapper);
+ if (problem == null) {
+ throw new BusinessException(ErrorCode.PROBLEM_NOT_FOUND, "No published problems available");
+ }
+ return ProblemVO.from(problem);
+ }
}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/queue/config/QueueConfig.java b/backend-spring/src/main/java/com/ulticode/modules/queue/config/QueueConfig.java
index 8002b9e55..49dac1d02 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/queue/config/QueueConfig.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/queue/config/QueueConfig.java
@@ -37,6 +37,11 @@ public class QueueConfig {
*/
private long pollIntervalMs = 1000;
+ /**
+ * Enable judge worker processing.
+ */
+ private boolean judgeEnabled = true;
+
/**
* Create the judge queue bean.
*
diff --git a/backend-spring/src/main/java/com/ulticode/modules/queue/processor/JudgeWorkerProcessor.java b/backend-spring/src/main/java/com/ulticode/modules/queue/processor/JudgeWorkerProcessor.java
new file mode 100644
index 000000000..1de7d3050
--- /dev/null
+++ b/backend-spring/src/main/java/com/ulticode/modules/queue/processor/JudgeWorkerProcessor.java
@@ -0,0 +1,309 @@
+package com.ulticode.modules.queue.processor;
+
+import com.ulticode.common.exception.BusinessException;
+import com.ulticode.common.exception.ErrorCode;
+import com.ulticode.modules.problem.entity.TestCase;
+import com.ulticode.modules.problem.mapper.TestCaseMapper;
+import com.ulticode.modules.queue.config.QueueConfig;
+import com.ulticode.modules.queue.constants.QueueConstants;
+import com.ulticode.modules.queue.dto.JobStatusDTO;
+import com.ulticode.modules.queue.job.JudgeJob;
+import com.ulticode.modules.queue.job.JobProcessor;
+import com.ulticode.modules.queue.service.QueueService;
+import com.ulticode.modules.submission.dto.RunResultDTO;
+import com.ulticode.modules.submission.dto.RunSubmissionDTO;
+import com.ulticode.modules.submission.entity.Submission;
+import com.ulticode.modules.submission.service.CodeExecutionService;
+import com.ulticode.modules.submission.service.SubmissionService;
+import com.ulticode.modules.websocket.contest.dto.SubmissionResultPayload;
+import com.ulticode.modules.websocket.service.RealtimeService;
+import com.ulticode.modules.contest.entity.ContestSubmission;
+import com.ulticode.modules.contest.mapper.ContestSubmissionMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Judge worker that polls the Redis judge queue and processes submissions.
+ *
+ * Wires together QueueService, CodeExecutionService, SubmissionService,
+ * and RealtimeService to form the complete judging pipeline:
+ *
+ *
+ * - Poll job from Redis queue
+ *
- Set submission status to "Judging"
+ *
- Load test cases, build RunSubmissionDTO, execute via Docker sandbox
+ *
- Determine verdict with priority ordering (RE > MLE > TLE > WA > PE > Accepted)
+ *
- Write result to Submission entity
+ *
- Push WebSocket notification to user
+ *
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+@ConditionalOnProperty(
+ name = "queue.judge.enabled",
+ havingValue = "true",
+ matchIfMissing = true
+)
+public class JudgeWorkerProcessor implements JobProcessor {
+
+ private static final Map VERDICT_PRIORITY = Map.of(
+ "Runtime Error", 5,
+ "Memory Limit Exceeded", 4,
+ "Time Limit Exceeded", 3,
+ "Wrong Answer", 2,
+ "Presentation Error", 1,
+ "Accepted", 0
+ );
+
+ private final QueueService queueService;
+ private final CodeExecutionService codeExecutionService;
+ private final SubmissionService submissionService;
+ private final RealtimeService realtimeService;
+ private final ContestSubmissionMapper contestSubmissionMapper;
+ private final TestCaseMapper testCaseMapper;
+ private final QueueConfig queueConfig;
+
+ private final AtomicInteger activeJobs = new AtomicInteger(0);
+
+ @Override
+ public String getJobType() {
+ return QueueConstants.JUDGE_QUEUE;
+ }
+
+ /**
+ * Poll the judge queue and process the next job.
+ * Guarded by maxConcurrentJobs to prevent unbounded concurrency.
+ */
+ @Scheduled(
+ fixedDelayString = "${queue.poll-interval-ms:1000}",
+ initialDelayString = "${queue.judge.initial-delay-ms:5000}"
+ )
+ public void pollAndProcess() {
+ try {
+ if (activeJobs.get() >= queueConfig.getMaxConcurrentJobs()) {
+ return;
+ }
+
+ Object polled = queueService.pollJob(QueueConstants.JUDGE_QUEUE);
+ if (!(polled instanceof JudgeJob judgeJob)) {
+ return;
+ }
+
+ activeJobs.incrementAndGet();
+ try {
+ processJob(judgeJob);
+ } finally {
+ activeJobs.decrementAndGet();
+ }
+ } catch (Exception e) {
+ log.error("JudgeWorkerProcessor.pollAndProcess failed", e);
+ }
+ }
+
+ /**
+ * Process a judge job: execute code, determine verdict, write result, push WebSocket.
+ */
+ public void processJob(JudgeJob job) {
+ String submissionId = job.getSubmissionId();
+ String problemId = job.getProblemId();
+ String userId = job.getUserId();
+
+ try {
+ // Mark as judging
+ submissionService.updateSubmissionResult(submissionId, "Judging", 0, null, null);
+
+ // Load test cases
+ List testCases = testCaseMapper.findByProblemIdOrderByOrder(Long.parseLong(problemId));
+ if (testCases == null || testCases.isEmpty()) {
+ log.warn("No test cases found for problem {}", problemId);
+ submissionService.updateSubmissionResult(submissionId, "System Error", 0, 0.0, null);
+ pushResult(userId, submissionId, problemId, "System Error", 0, 0L, null);
+ return;
+ }
+
+ // Build RunSubmissionDTO
+ RunSubmissionDTO runDto = buildRunSubmissionDTO(job, testCases);
+
+ // Execute
+ RunResultDTO result = codeExecutionService.execute(runDto, Long.parseLong(problemId), userId);
+
+ // Determine verdict
+ String verdict = determineVerdict(result.getCases());
+
+ // Compute max runtime and memory across all cases
+ long maxRuntimeMs = 0;
+ double maxMemoryMb = 0.0;
+ for (RunResultDTO.RunCaseResult caseResult : result.getCases()) {
+ maxRuntimeMs = Math.max(maxRuntimeMs, parseRuntimeMs(caseResult.getRuntime()));
+ maxMemoryMb = Math.max(maxMemoryMb, parseMemoryMb(caseResult.getMemory()));
+ }
+
+ // Build test case details
+ List testCaseDetails = result.getCases().stream()
+ .map(cr -> {
+ Submission.TestCaseDetail detail = new Submission.TestCaseDetail();
+ detail.setStatus(cr.getStatus());
+ detail.setTime((int) parseRuntimeMs(cr.getRuntime()));
+ detail.setMemory(parseMemoryMb(cr.getMemory()));
+ detail.setOutput(cr.getOutput());
+ detail.setExpectedOutput(cr.getExpectedOutput());
+ detail.setDetail(cr.getDetail());
+ return detail;
+ })
+ .toList();
+
+ // Write result
+ submissionService.updateSubmissionResult(submissionId, verdict, (int) maxRuntimeMs, maxMemoryMb, testCaseDetails);
+
+ // Push WebSocket
+ long memoryBytes = (long) (maxMemoryMb * 1024 * 1024);
+ String contestId = findContestIdBySubmissionId(submissionId);
+ pushResult(userId, submissionId, problemId, verdict, (int) maxRuntimeMs, memoryBytes, contestId);
+
+ } catch (Exception e) {
+ log.error("Failed to process judge job for submission {}", submissionId, e);
+ throw new RuntimeException("Judge processing failed for submission " + submissionId, e);
+ }
+ }
+
+ @Override
+ public JobStatusDTO process(JudgeJob job) throws Exception {
+ processJob(job);
+ return JobStatusDTO.builder()
+ .jobId(job.getId())
+ .jobType(getJobType())
+ .status(QueueConstants.JobStatus.COMPLETED)
+ .build();
+ }
+
+ @Override
+ public boolean shouldRetry(JudgeJob job, Exception error, int attempts, int maxRetries) {
+ // Don't retry compile errors
+ if (error.getMessage() != null
+ && error.getMessage().toLowerCase().contains("compile")) {
+ return false;
+ }
+ // Don't retry unsupported language errors
+ if (error instanceof BusinessException bizEx
+ && bizEx.getErrorCode() == ErrorCode.SUBMISSION_LANGUAGE_UNSUPPORTED) {
+ return false;
+ }
+ return attempts < maxRetries;
+ }
+
+ @Override
+ public void onFailure(JudgeJob job, Exception error) {
+ if (shouldRetry(job, error, job.getAttempts(), job.getMaxRetries())) {
+ try {
+ long delay = (long) (2000 * Math.pow(2, job.getAttempts()));
+ Thread.sleep(delay);
+ queueService.retryJob(job.getId());
+ log.info("Retrying judge job {} after {}ms", job.getId(), delay);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.warn("Retry sleep interrupted for job {}", job.getId());
+ }
+ } else {
+ log.error("All retries exhausted for judge job {}, marking as System Error", job.getId(), error);
+ submissionService.updateSubmissionResult(
+ job.getSubmissionId(), "System Error", 0, 0.0, null);
+ String failedContestId = findContestIdBySubmissionId(job.getSubmissionId());
+ pushResult(job.getUserId(), job.getSubmissionId(), job.getProblemId(),
+ "System Error", 0, 0L, failedContestId);
+ }
+ }
+
+ /**
+ * Determine the final verdict from case results using priority ordering.
+ * Priority: Runtime Error > Memory Limit Exceeded > Time Limit Exceeded
+ * > Wrong Answer > Presentation Error > Accepted.
+ */
+ String determineVerdict(List cases) {
+ if (cases == null || cases.isEmpty()) {
+ return "System Error";
+ }
+
+ int highestPriority = -1;
+ String worstVerdict = "Accepted";
+
+ for (RunResultDTO.RunCaseResult caseResult : cases) {
+ int priority = VERDICT_PRIORITY.getOrDefault(caseResult.getStatus(), 0);
+ if (priority > highestPriority) {
+ highestPriority = priority;
+ worstVerdict = caseResult.getStatus();
+ }
+ }
+
+ return worstVerdict;
+ }
+
+ /**
+ * Parse runtime string like "123ms" to milliseconds.
+ */
+ long parseRuntimeMs(String runtime) {
+ if (runtime == null || runtime.isBlank()) {
+ return 0L;
+ }
+ try {
+ return Long.parseLong(runtime.replace("ms", "").trim());
+ } catch (NumberFormatException e) {
+ return 0L;
+ }
+ }
+
+ /**
+ * Parse memory string like "4.2MB" to megabytes.
+ */
+ double parseMemoryMb(String memory) {
+ if (memory == null || memory.isBlank()) {
+ return 0.0;
+ }
+ try {
+ return Double.parseDouble(memory.replace("MB", "").trim());
+ } catch (NumberFormatException e) {
+ return 0.0;
+ }
+ }
+
+ private RunSubmissionDTO buildRunSubmissionDTO(JudgeJob job, List testCases) {
+ RunSubmissionDTO runDto = new RunSubmissionDTO();
+ runDto.setLanguage(job.getLanguage());
+ runDto.setCode(job.getCode());
+ runDto.setTestCases(testCases.stream().map(tc -> {
+ RunSubmissionDTO.RunTestCase rtc = new RunSubmissionDTO.RunTestCase();
+ rtc.setId(String.valueOf(tc.getId()));
+ rtc.setLabel("Case " + tc.getTestOrder());
+ rtc.setOutput(tc.getOutputText());
+ RunSubmissionDTO.RunInput input = new RunSubmissionDTO.RunInput();
+ input.setId("0");
+ input.setLabel("input");
+ input.setName("input");
+ input.setValue(tc.getInputText());
+ rtc.setInputs(List.of(input));
+ return rtc;
+ }).toList());
+ return runDto;
+ }
+
+ private void pushResult(String userId, String submissionId, String problemId,
+ String status, int timeUsed, long memoryUsed, String contestId) {
+ SubmissionResultPayload payload = SubmissionResultPayload.of(
+ submissionId, contestId, problemId, userId, status, 0, timeUsed, memoryUsed);
+ realtimeService.emitSubmissionResult(userId, payload);
+ }
+
+ private String findContestIdBySubmissionId(String submissionId) {
+ ContestSubmission cs = contestSubmissionMapper.selectOne(
+ new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper()
+ .eq(ContestSubmission::getSubmissionId, submissionId));
+ return cs != null ? cs.getContestId() : null;
+ }
+}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/submission/mapper/SubmissionMapper.java b/backend-spring/src/main/java/com/ulticode/modules/submission/mapper/SubmissionMapper.java
index 2be8941ed..da50aad89 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/submission/mapper/SubmissionMapper.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/submission/mapper/SubmissionMapper.java
@@ -369,4 +369,33 @@ long countDistinctUsersInRange(
+ "WHERE contest_id IN (${contestIds}) "
+ "GROUP BY contest_id")
List> countParticipantsByContest(@Param("contestIds") String contestIds);
+
+ /**
+ * Get global rank for a user from global_rankings table.
+ *
+ * @param userId user ID
+ * @return the global rank, or null if user not in rankings
+ */
+ @Select("SELECT global_rank FROM global_rankings WHERE user_id = #{userId}")
+ Integer findGlobalRankByUserId(@Param("userId") String userId);
+
+ /**
+ * Calculate acceptance rate for a user (percentage of accepted submissions).
+ *
+ * @param userId user ID
+ * @return the acceptance rate as a percentage (0-100), or null if no submissions
+ */
+ @Select("SELECT " +
+ "SUM(CASE WHEN status = 'Accepted' THEN 1 ELSE 0 END) * 100.0 / NULLIF(COUNT(*), 0) " +
+ "FROM submissions WHERE user_id = #{userId}")
+ Double calculateAcceptanceRateByUserId(@Param("userId") String userId);
+
+ /**
+ * Count total submissions for a user.
+ *
+ * @param userId user ID
+ * @return the total number of submissions
+ */
+ @Select("SELECT COUNT(*) FROM submissions WHERE user_id = #{userId}")
+ Long countTotalSubmissionsByUserId(@Param("userId") String userId);
}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/submission/service/CodeExecutionService.java b/backend-spring/src/main/java/com/ulticode/modules/submission/service/CodeExecutionService.java
index b2a4ecf22..52d797159 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/submission/service/CodeExecutionService.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/submission/service/CodeExecutionService.java
@@ -82,7 +82,10 @@ public RunResultDTO execute(RunSubmissionDTO request, Long problemId, String use
.userId(userId)
.verdict(verdict)
.runtime(totalRuntimeMs + "ms")
- .memory("0KB")
+ .memory(results.stream()
+ .map(RunResultDTO.RunCaseResult::getMemory)
+ .max(String::compareTo)
+ .orElse("0.0MB"))
.cases(results)
.passedCases(passedCases)
.totalCases(testCases.size())
@@ -113,7 +116,7 @@ private RunResultDTO.RunCaseResult executeInSandbox(String language, String code
if (!finished) {
process.destroyForcibly();
return buildCaseResult(testCase, runId, userId, "Time Limit Exceeded",
- elapsedMs, null, "Execution timed out after " + sandboxConfig.timeout() + "s");
+ elapsedMs, null, "Execution timed out after " + sandboxConfig.timeout() + "s", 0.0);
}
String stdout = new String(process.getInputStream().readAllBytes(), StandardCharsets.UTF_8).trim();
@@ -121,7 +124,7 @@ private RunResultDTO.RunCaseResult executeInSandbox(String language, String code
if (exitCode != 0) {
return buildCaseResult(testCase, runId, userId, "Runtime Error",
- elapsedMs, null, sanitizeSandboxOutput(stdout));
+ elapsedMs, null, sanitizeSandboxOutput(stdout), 0.0);
}
String expected = testCase.getOutput() != null ? testCase.getOutput().trim() : "";
@@ -129,7 +132,7 @@ private RunResultDTO.RunCaseResult executeInSandbox(String language, String code
return buildCaseResult(testCase, runId, userId,
passed ? "Accepted" : "Wrong Answer",
- elapsedMs, stdout, null);
+ elapsedMs, stdout, null, 0.0);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
@@ -232,7 +235,7 @@ private List executeBatch(
return testCases.stream()
.map(tc -> buildCaseResult(tc, runId, userId, "Time Limit Exceeded",
elapsedMs / testCases.size(), null,
- "Batch execution timed out after " + sandboxConfig.timeout() + "s"))
+ "Batch execution timed out after " + sandboxConfig.timeout() + "s", 0.0))
.collect(Collectors.toList());
}
@@ -242,7 +245,7 @@ private List executeBatch(
if (exitCode != 0) {
return testCases.stream()
.map(tc -> buildCaseResult(tc, runId, userId, "Runtime Error",
- elapsedMs / testCases.size(), null, sanitizeSandboxOutput(stdout)))
+ elapsedMs / testCases.size(), null, sanitizeSandboxOutput(stdout), 0.0))
.collect(Collectors.toList());
}
@@ -276,9 +279,10 @@ private String buildJavaScriptBatchWrapper(String code, List parseBatchResults(
if (jsonStart < 0 || jsonEnd < 0 || jsonEnd <= jsonStart) {
return testCases.stream()
.map(tc -> buildCaseResult(tc, runId, userId, "Runtime Error",
- 0, null, "Failed to parse batch results: " + sanitizeSandboxOutput(stdout)))
+ 0, null, "Failed to parse batch results: " + sanitizeSandboxOutput(stdout), 0.0))
.collect(Collectors.toList());
}
@@ -418,18 +439,21 @@ private List parseBatchResults(
String output = result.get("output") != null ? result.get("output").toString() : "";
long runtime = result.get("runtime") != null ? ((Number) result.get("runtime")).longValue() : 0;
String status = result.get("status") != null ? result.get("status").toString() : "error";
+ long memoryBytes = result.get("memory") != null
+ ? ((Number) result.get("memory")).longValue() : 0;
+ double memoryMb = memoryBytes / (1024.0 * 1024.0);
if ("timeout".equals(status)) {
caseResults.add(buildCaseResult(testCase, runId, userId,
- "Time Limit Exceeded", runtime, null, "Per-case timeout exceeded"));
+ "Time Limit Exceeded", runtime, null, "Per-case timeout exceeded", 0.0));
} else if ("error".equals(status)) {
caseResults.add(buildCaseResult(testCase, runId, userId,
- "Runtime Error", runtime, null, sanitizeSandboxOutput(output)));
+ "Runtime Error", runtime, null, sanitizeSandboxOutput(output), 0.0));
} else {
String expected = testCase.getOutput() != null ? testCase.getOutput().trim() : "";
boolean passed = normalizeOutput(output).equals(normalizeOutput(expected));
caseResults.add(buildCaseResult(testCase, runId, userId,
- passed ? "Accepted" : "Wrong Answer", runtime, output, null));
+ passed ? "Accepted" : "Wrong Answer", runtime, output, null, memoryMb));
}
}
return caseResults;
@@ -438,7 +462,7 @@ private List parseBatchResults(
log.error("Failed to parse batch results", e);
return testCases.stream()
.map(tc -> buildCaseResult(tc, runId, userId, "Runtime Error",
- 0, null, "Result parsing failed: " + e.getMessage()))
+ 0, null, "Result parsing failed: " + e.getMessage(), 0.0))
.collect(Collectors.toList());
}
}
@@ -577,7 +601,7 @@ private RunResultDTO emptyResult(Long problemId, String userId) {
.userId(userId)
.verdict("Accepted")
.runtime("0ms")
- .memory("0KB")
+ .memory("0.0MB")
.cases(List.of())
.passedCases(0)
.totalCases(0)
@@ -587,7 +611,8 @@ private RunResultDTO emptyResult(Long problemId, String userId) {
private RunResultDTO.RunCaseResult buildCaseResult(RunSubmissionDTO.RunTestCase testCase,
String runId, String userId,
String status, long runtimeMs,
- String output, String detail) {
+ String output, String detail,
+ double memoryMb) {
List inputs = null;
if (testCase.getInputs() != null) {
inputs = testCase.getInputs().stream()
@@ -608,7 +633,7 @@ private RunResultDTO.RunCaseResult buildCaseResult(RunSubmissionDTO.RunTestCase
.caseLabel(testCase.getLabel() != null ? testCase.getLabel() : testCase.getId())
.status(status)
.runtime(runtimeMs + "ms")
- .memory("0KB")
+ .memory(String.format("%.1fMB", memoryMb))
.output(output)
.expectedOutput(testCase.getOutput())
.detail(detail)
diff --git a/backend-spring/src/main/java/com/ulticode/modules/submission/service/impl/SubmissionServiceImpl.java b/backend-spring/src/main/java/com/ulticode/modules/submission/service/impl/SubmissionServiceImpl.java
index 5e568dd1d..2a6d50966 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/submission/service/impl/SubmissionServiceImpl.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/submission/service/impl/SubmissionServiceImpl.java
@@ -21,6 +21,17 @@
import com.ulticode.modules.submission.mapper.SubmissionMapper;
import com.ulticode.modules.submission.service.SubmissionService;
import com.ulticode.modules.queue.service.QueueService;
+import com.ulticode.modules.websocket.service.RealtimeService;
+import com.ulticode.modules.contest.entity.Contest;
+import com.ulticode.modules.contest.entity.ContestParticipant;
+import com.ulticode.modules.contest.entity.ContestProblem;
+import com.ulticode.modules.contest.entity.ContestSubmission;
+import com.ulticode.modules.contest.entity.enums.ContestStatus;
+import com.ulticode.modules.contest.entity.enums.ContestParticipantStatus;
+import com.ulticode.modules.contest.mapper.ContestMapper;
+import com.ulticode.modules.contest.mapper.ContestProblemMapper;
+import com.ulticode.modules.contest.mapper.ContestSubmissionMapper;
+import com.ulticode.modules.contest.mapper.ContestParticipantMapper;
import com.ulticode.modules.user.entity.User;
import com.ulticode.modules.user.mapper.UserMapper;
import lombok.RequiredArgsConstructor;
@@ -29,6 +40,7 @@
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
+import java.time.Duration;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
@@ -47,13 +59,17 @@ public class SubmissionServiceImpl implements SubmissionService {
private final UserMapper userMapper;
private final ProblemMapper problemMapper;
private final QueueService queueService;
+ private final RealtimeService realtimeService;
+ private final ContestProblemMapper contestProblemMapper;
+ private final ContestSubmissionMapper contestSubmissionMapper;
+ private final ContestMapper contestMapper;
+ private final ContestParticipantMapper contestParticipantMapper;
/**
* Supported languages for submission.
*/
private static final List SUPPORTED_LANGUAGES = List.of(
- "javascript", "typescript", "python", "java", "cpp", "c",
- "go", "rust", "csharp", "php", "ruby", "swift", "kotlin"
+ "javascript", "python", "java", "c", "cpp"
);
@Override
@@ -105,6 +121,14 @@ public SubmissionVO submit(String userId, CreateSubmissionDTO createDTO) {
log.info("Created submission {} for user {} and problem {}", submission.getId(), userId, createDTO.getProblemId());
+ // --- Contest submission recording (D-04, D-05, D-06) ---
+ try {
+ recordContestSubmissionIfNeeded(submission.getId(), userId, createDTO.getProblemId());
+ } catch (Exception e) {
+ log.warn("Failed to record contest submission for submission {}", submission.getId(), e);
+ // Don't fail the main submission -- contest recording is supplementary
+ }
+
try {
queueService.enqueueJudgeJob(
submission.getId(),
@@ -522,4 +546,46 @@ public List getStatuses() {
return statuses;
}
+
+ /**
+ * Record contest submission if user is participating in an active contest containing this problem.
+ * Per D-04: creates ContestSubmission alongside regular Submission in same transaction.
+ * Per D-06: only records if user has STARTED status (matches DB enum).
+ */
+ private void recordContestSubmissionIfNeeded(String submissionId, String userId, Long problemId) {
+ // 1. Find contest_problems containing this problem
+ List contestProblems = contestProblemMapper.findByProblemId(problemId);
+
+ for (ContestProblem cp : contestProblems) {
+ // 2. Check if contest is RUNNING
+ Contest contest = contestMapper.selectById(cp.getContestId());
+ if (contest == null || !ContestStatus.RUNNING.name().equals(contest.getStatus())) {
+ continue;
+ }
+
+ // 3. Check if user has STARTED status (D-06 -- matches DB enum 'STARTED')
+ Optional participant = contestParticipantMapper
+ .findByContestIdAndUserId(cp.getContestId(), userId);
+ if (participant.isEmpty() ||
+ !ContestParticipantStatus.STARTED.name().equals(participant.get().getStatus())) {
+ continue;
+ }
+
+ // 4. Create ContestSubmission (D-05)
+ ContestSubmission cs = new ContestSubmission();
+ cs.setSubmissionId(submissionId);
+ cs.setContestId(cp.getContestId());
+ cs.setContestProblemId(cp.getId());
+ cs.setParticipantId(participant.get().getId());
+ cs.setTimeFromStart((int) Duration.between(
+ contest.getStartTime(), LocalDateTime.now()).getSeconds());
+ cs.setIsAccepted(false); // Will be updated when judge completes
+ cs.setSubmittedAt(LocalDateTime.now());
+ contestSubmissionMapper.insert(cs);
+ realtimeService.markDirty(contest.getId());
+
+ // Only record for the first matching active contest
+ break;
+ }
+ }
}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/user/dto/UserStatsDTO.java b/backend-spring/src/main/java/com/ulticode/modules/user/dto/UserStatsDTO.java
index ee87f0bb1..ee10d74f3 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/user/dto/UserStatsDTO.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/user/dto/UserStatsDTO.java
@@ -31,6 +31,21 @@ public class UserStatsDTO {
*/
private int totalSolved;
+ /**
+ * Global rank based on contest rating.
+ */
+ private Integer globalRank;
+
+ /**
+ * Acceptance rate (percentage of submissions that were accepted).
+ */
+ private Double acceptanceRate;
+
+ /**
+ * Total number of submissions made by the user.
+ */
+ private Long submissionCount;
+
/**
* Heatmap data showing submission activity by date.
*/
diff --git a/backend-spring/src/main/java/com/ulticode/modules/user/service/impl/UserServiceImpl.java b/backend-spring/src/main/java/com/ulticode/modules/user/service/impl/UserServiceImpl.java
index 86c422d21..0309a1e1c 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/user/service/impl/UserServiceImpl.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/user/service/impl/UserServiceImpl.java
@@ -255,6 +255,18 @@ public UserStatsDTO getUserStatsById(String id) {
stats.setHeatmap(heatmap);
+ // Get global rank from global_rankings
+ Integer globalRank = submissionMapper.findGlobalRankByUserId(id);
+ stats.setGlobalRank(globalRank);
+
+ // Get acceptance rate
+ Double acceptanceRate = submissionMapper.calculateAcceptanceRateByUserId(id);
+ stats.setAcceptanceRate(acceptanceRate);
+
+ // Get total submission count
+ Long submissionCount = submissionMapper.countTotalSubmissionsByUserId(id);
+ stats.setSubmissionCount(submissionCount);
+
return stats;
}
diff --git a/backend-spring/src/main/java/com/ulticode/modules/websocket/service/RealtimeService.java b/backend-spring/src/main/java/com/ulticode/modules/websocket/service/RealtimeService.java
index 7b8575da2..f710269a8 100644
--- a/backend-spring/src/main/java/com/ulticode/modules/websocket/service/RealtimeService.java
+++ b/backend-spring/src/main/java/com/ulticode/modules/websocket/service/RealtimeService.java
@@ -10,10 +10,13 @@
import com.ulticode.modules.websocket.event.ContestStatusEvent;
import com.ulticode.modules.websocket.event.ContestStatusEvent.ContestStatus;
import com.ulticode.modules.websocket.util.WebSocketUtils;
+import com.ulticode.modules.contest.service.RankingService;
import java.time.Instant;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.messaging.simp.SimpMessagingTemplate;
@@ -43,6 +46,7 @@ public class RealtimeService {
private final SimpMessagingTemplate messagingTemplate;
private final WebSocketProperties properties;
+ private final RankingService rankingService;
/** Track last push time per contest for throttling. */
private final Map lastRankingPushTime = new ConcurrentHashMap<>();
@@ -50,9 +54,11 @@ public class RealtimeService {
/** Pending ranking updates that need to be pushed. */
private final Map pendingRankingUpdates = new ConcurrentHashMap<>();
- public RealtimeService(SimpMessagingTemplate messagingTemplate, WebSocketProperties properties) {
+ public RealtimeService(SimpMessagingTemplate messagingTemplate, WebSocketProperties properties,
+ RankingService rankingService) {
this.messagingTemplate = messagingTemplate;
this.properties = properties;
+ this.rankingService = rankingService;
}
/**
@@ -145,6 +151,48 @@ public void emitSubmissionResult(String userId, SubmissionResultPayload payload)
log.debug("Submission result sent to user {}: {}", userId, payload.status());
}
+ /**
+ * Mark a contest's ranking as dirty, requiring a flush on next throttle tick.
+ *
+ * @param contestId the contest ID
+ */
+ public void markDirty(String contestId) {
+ pendingRankingUpdates.putIfAbsent(contestId, true);
+ }
+
+ /**
+ * Flush pending ranking updates, emitting at most once per second per contest.
+ * Called every second by the scheduler.
+ */
+ @Scheduled(fixedRate = 1000)
+ public void flushPendingRankings() {
+ Set dirty = Set.copyOf(pendingRankingUpdates.keySet());
+ pendingRankingUpdates.clear();
+
+ for (String contestId : dirty) {
+ Long lastPush = lastRankingPushTime.get(contestId);
+ long elapsed = System.currentTimeMillis() - (lastPush != null ? lastPush : 0);
+
+ if (elapsed >= RANKING_THROTTLE_MS) {
+ List rankings = rankingService.getLiveRanking(contestId, 200).stream()
+ .map(vo -> new RankingItem(
+ vo.getRank() != null ? vo.getRank() : 0,
+ vo.getUserId() != null ? vo.getUserId().toString() : "",
+ vo.getUsername() != null ? vo.getUsername() : "",
+ vo.getScore() != null ? vo.getScore().doubleValue() : 0.0,
+ vo.getPenalty() != null ? vo.getPenalty().intValue() : 0,
+ vo.getProblemsSolved() != null ? vo.getProblemsSolved() : 0
+ ))
+ .collect(Collectors.toList());
+ emitRankingUpdate(contestId, rankings);
+ lastRankingPushTime.put(contestId, System.currentTimeMillis());
+ } else {
+ // Re-mark as dirty for next flush cycle
+ pendingRankingUpdates.putIfAbsent(contestId, true);
+ }
+ }
+ }
+
/**
* Broadcast to all connected clients.
*
diff --git a/backend-spring/src/test/java/com/ulticode/modules/queue/processor/JudgeWorkerProcessorTest.java b/backend-spring/src/test/java/com/ulticode/modules/queue/processor/JudgeWorkerProcessorTest.java
new file mode 100644
index 000000000..95c427482
--- /dev/null
+++ b/backend-spring/src/test/java/com/ulticode/modules/queue/processor/JudgeWorkerProcessorTest.java
@@ -0,0 +1,462 @@
+package com.ulticode.modules.queue.processor;
+
+import com.ulticode.common.exception.BusinessException;
+import com.ulticode.common.exception.ErrorCode;
+import com.ulticode.modules.problem.entity.TestCase;
+import com.ulticode.modules.problem.mapper.TestCaseMapper;
+import com.ulticode.modules.queue.config.QueueConfig;
+import com.ulticode.modules.queue.dto.JobStatusDTO;
+import com.ulticode.modules.queue.job.JudgeJob;
+import com.ulticode.modules.queue.service.QueueService;
+import com.ulticode.modules.submission.dto.RunResultDTO;
+import com.ulticode.modules.submission.dto.RunSubmissionDTO;
+import com.ulticode.modules.submission.entity.Submission;
+import com.ulticode.modules.submission.service.CodeExecutionService;
+import com.ulticode.modules.submission.service.SubmissionService;
+import com.ulticode.modules.websocket.contest.dto.SubmissionResultPayload;
+import com.ulticode.modules.websocket.service.RealtimeService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+@DisplayName("JudgeWorkerProcessor")
+class JudgeWorkerProcessorTest {
+
+ @Mock
+ private QueueService queueService;
+
+ @Mock
+ private CodeExecutionService codeExecutionService;
+
+ @Mock
+ private SubmissionService submissionService;
+
+ @Mock
+ private RealtimeService realtimeService;
+
+ @Mock
+ private TestCaseMapper testCaseMapper;
+
+ @Mock
+ private QueueConfig queueConfig;
+
+ @InjectMocks
+ private JudgeWorkerProcessor processor;
+
+ @Captor
+ private ArgumentCaptor payloadCaptor;
+
+ @Captor
+ private ArgumentCaptor> detailsCaptor;
+
+ private JudgeJob sampleJob;
+
+ @BeforeEach
+ void setUp() {
+ sampleJob = JudgeJob.create("sub-1", "100", "user-1", "javascript", "console.log('hello');");
+ lenient().when(queueConfig.getMaxConcurrentJobs()).thenReturn(10);
+ }
+
+ // === getJobType ===
+
+ @Test
+ @DisplayName("getJobType returns JUDGE_QUEUE")
+ void getJobType_returnsJudgeQueue() {
+ assertThat(processor.getJobType()).isEqualTo("judge_queue");
+ }
+
+ // === pollAndProcess ===
+
+ @Nested
+ @DisplayName("pollAndProcess")
+ class PollAndProcess {
+
+ @Test
+ @DisplayName("does nothing when queue is empty")
+ void emptyQueue_doesNothing() {
+ when(queueService.pollJob("judge_queue")).thenReturn(null);
+
+ processor.pollAndProcess();
+
+ verify(submissionService, never()).updateSubmissionResult(anyString(), anyString(),
+ anyInt(), any(), any());
+ }
+
+ @Test
+ @DisplayName("processes JudgeJob and decrements activeJobs")
+ void withJudgeJob_processesAndDecrementsActiveJobs() {
+ when(queueService.pollJob("judge_queue")).thenReturn(sampleJob);
+ when(testCaseMapper.findByProblemIdOrderByOrder(100L))
+ .thenReturn(buildTestCases(2));
+ when(codeExecutionService.execute(any(RunSubmissionDTO.class), eq(100L), eq("user-1")))
+ .thenReturn(buildAcceptedResult(2));
+
+ processor.pollAndProcess();
+
+ verify(submissionService).updateSubmissionResult(eq("sub-1"), eq("Accepted"),
+ anyInt(), any(), any());
+ verify(realtimeService).emitSubmissionResult(eq("user-1"), payloadCaptor.capture());
+ assertThat(payloadCaptor.getValue().status()).isEqualTo("Accepted");
+ }
+
+ @Test
+ @DisplayName("returns early when max concurrent jobs reached")
+ void maxConcurrentJobs_returnsEarly() {
+ when(queueConfig.getMaxConcurrentJobs()).thenReturn(0);
+
+ processor.pollAndProcess();
+
+ verify(queueService, never()).pollJob(anyString());
+ }
+
+ @Test
+ @DisplayName("catches exception to prevent scheduler death")
+ void exception_caughtAndLogged() {
+ when(queueService.pollJob("judge_queue")).thenThrow(new RuntimeException("Redis down"));
+
+ // Should not throw
+ processor.pollAndProcess();
+ }
+ }
+
+ // === processJob ===
+
+ @Nested
+ @DisplayName("processJob")
+ class ProcessJob {
+
+ @Test
+ @DisplayName("sets status to Judging, executes, writes verdict")
+ void setsJudgingThenWritesVerdict() {
+ when(testCaseMapper.findByProblemIdOrderByOrder(100L))
+ .thenReturn(buildTestCases(1));
+ when(codeExecutionService.execute(any(RunSubmissionDTO.class), eq(100L), eq("user-1")))
+ .thenReturn(buildAcceptedResult(1));
+
+ processor.processJob(sampleJob);
+
+ var statusOrder = inOrder(submissionService);
+ statusOrder.verify(submissionService).updateSubmissionResult(
+ eq("sub-1"), eq("Judging"), eq(0), isNull(), isNull());
+ statusOrder.verify(submissionService).updateSubmissionResult(
+ eq("sub-1"), eq("Accepted"), anyInt(), any(), any());
+ }
+
+ @Test
+ @DisplayName("null test cases marks as System Error")
+ void nullTestCases_marksSystemError() {
+ when(testCaseMapper.findByProblemIdOrderByOrder(100L)).thenReturn(null);
+
+ processor.processJob(sampleJob);
+
+ verify(submissionService).updateSubmissionResult(
+ eq("sub-1"), eq("System Error"), eq(0), eq(0.0), isNull());
+ verify(realtimeService).emitSubmissionResult(eq("user-1"), payloadCaptor.capture());
+ assertThat(payloadCaptor.getValue().status()).isEqualTo("System Error");
+ }
+
+ @Test
+ @DisplayName("empty test cases marks as System Error")
+ void emptyTestCases_marksSystemError() {
+ when(testCaseMapper.findByProblemIdOrderByOrder(100L)).thenReturn(List.of());
+
+ processor.processJob(sampleJob);
+
+ verify(submissionService).updateSubmissionResult(
+ eq("sub-1"), eq("System Error"), eq(0), eq(0.0), isNull());
+ }
+
+ @Test
+ @DisplayName("pushes WebSocket result after writing verdict")
+ void pushesWebSocketAfterVerdict() {
+ when(testCaseMapper.findByProblemIdOrderByOrder(100L))
+ .thenReturn(buildTestCases(1));
+ when(codeExecutionService.execute(any(RunSubmissionDTO.class), eq(100L), eq("user-1")))
+ .thenReturn(buildWrongAnswerResult(1));
+
+ processor.processJob(sampleJob);
+
+ var inOrder = inOrder(submissionService, realtimeService);
+ inOrder.verify(submissionService).updateSubmissionResult(
+ eq("sub-1"), eq("Wrong Answer"), anyInt(), any(), any());
+ inOrder.verify(realtimeService).emitSubmissionResult(eq("user-1"), any());
+ }
+ }
+
+ // === determineVerdict ===
+
+ @Nested
+ @DisplayName("determineVerdict")
+ class DetermineVerdict {
+
+ @Test
+ @DisplayName("returns Runtime Error when any case has RE (highest priority)")
+ void runtimeError_hasHighestPriority() {
+ var cases = List.of(
+ buildCaseResult("Accepted", "50ms", "4.0MB"),
+ buildCaseResult("Runtime Error", "100ms", "8.0MB"),
+ buildCaseResult("Accepted", "30ms", "3.0MB")
+ );
+
+ String verdict = processor.determineVerdict(cases);
+
+ assertThat(verdict).isEqualTo("Runtime Error");
+ }
+
+ @Test
+ @DisplayName("returns Accepted when all cases pass")
+ void allAccepted_returnsAccepted() {
+ var cases = List.of(
+ buildCaseResult("Accepted", "50ms", "4.0MB"),
+ buildCaseResult("Accepted", "30ms", "3.0MB")
+ );
+
+ String verdict = processor.determineVerdict(cases);
+
+ assertThat(verdict).isEqualTo("Accepted");
+ }
+
+ @Test
+ @DisplayName("returns Wrong Answer when any case fails with WA")
+ void wrongAnswer_whenPresent() {
+ var cases = List.of(
+ buildCaseResult("Accepted", "50ms", "4.0MB"),
+ buildCaseResult("Wrong Answer", "30ms", "3.0MB")
+ );
+
+ String verdict = processor.determineVerdict(cases);
+
+ assertThat(verdict).isEqualTo("Wrong Answer");
+ }
+
+ @Test
+ @DisplayName("returns TLE when any case times out")
+ void timeLimitExceeded_whenPresent() {
+ var cases = List.of(
+ buildCaseResult("Accepted", "50ms", "4.0MB"),
+ buildCaseResult("Time Limit Exceeded", "2000ms", "4.0MB")
+ );
+
+ String verdict = processor.determineVerdict(cases);
+
+ assertThat(verdict).isEqualTo("Time Limit Exceeded");
+ }
+
+ @Test
+ @DisplayName("priority order: RE > MLE > TLE > WA > PE > Accepted")
+ void fullPriorityOrder() {
+ var cases = List.of(
+ buildCaseResult("Accepted", "10ms", "1.0MB"),
+ buildCaseResult("Presentation Error", "10ms", "1.0MB"),
+ buildCaseResult("Wrong Answer", "10ms", "1.0MB"),
+ buildCaseResult("Time Limit Exceeded", "2000ms", "1.0MB"),
+ buildCaseResult("Memory Limit Exceeded", "10ms", "256.0MB"),
+ buildCaseResult("Runtime Error", "10ms", "1.0MB")
+ );
+
+ assertThat(processor.determineVerdict(cases)).isEqualTo("Runtime Error");
+ }
+ }
+
+ // === shouldRetry ===
+
+ @Nested
+ @DisplayName("shouldRetry")
+ class ShouldRetry {
+
+ @Test
+ @DisplayName("returns false for compile errors")
+ void compileError_noRetry() {
+ Exception error = new RuntimeException("Compile error: invalid syntax");
+
+ boolean result = processor.shouldRetry(sampleJob, error, 0, 3);
+
+ assertThat(result).isFalse();
+ }
+
+ @Test
+ @DisplayName("returns false for SUBMISSION_LANGUAGE_UNSUPPORTED BusinessException")
+ void unsupportedLanguage_noRetry() {
+ Exception error = new BusinessException(ErrorCode.SUBMISSION_LANGUAGE_UNSUPPORTED);
+
+ boolean result = processor.shouldRetry(sampleJob, error, 0, 3);
+
+ assertThat(result).isFalse();
+ }
+
+ @Test
+ @DisplayName("returns true for transient failures when attempts < maxRetries")
+ void transientFailure_shouldRetry() {
+ Exception error = new RuntimeException("Docker timeout");
+
+ boolean result = processor.shouldRetry(sampleJob, error, 1, 3);
+
+ assertThat(result).isTrue();
+ }
+
+ @Test
+ @DisplayName("returns false when attempts >= maxRetries")
+ void exhaustedRetries_noRetry() {
+ Exception error = new RuntimeException("Docker timeout");
+
+ boolean result = processor.shouldRetry(sampleJob, error, 3, 3);
+
+ assertThat(result).isFalse();
+ }
+ }
+
+ // === onFailure ===
+
+ @Nested
+ @DisplayName("onFailure")
+ class OnFailure {
+
+ @Test
+ @DisplayName("marks submission as System Error when retries exhausted")
+ void retriesExhausted_marksSystemError() {
+ sampleJob.setAttempts(3);
+
+ processor.onFailure(sampleJob, new RuntimeException("Docker down"));
+
+ verify(submissionService).updateSubmissionResult(
+ eq("sub-1"), eq("System Error"), eq(0), eq(0.0), isNull());
+ verify(realtimeService).emitSubmissionResult(eq("user-1"), payloadCaptor.capture());
+ assertThat(payloadCaptor.getValue().status()).isEqualTo("System Error");
+ }
+
+ @Test
+ @DisplayName("retries job when shouldRetry returns true")
+ void retryableError_retriesJob() {
+ sampleJob.setAttempts(1);
+
+ processor.onFailure(sampleJob, new RuntimeException("Transient failure"));
+
+ verify(queueService).retryJob(eq(sampleJob.getId()));
+ }
+ }
+
+ // === parseMemoryMb ===
+
+ @Nested
+ @DisplayName("parseMemoryMb")
+ class ParseMemoryMb {
+
+ @Test
+ @DisplayName("parses standard MB format")
+ void standardFormat() {
+ assertThat(processor.parseMemoryMb("4.2MB")).isEqualTo(4.2);
+ }
+
+ @Test
+ @DisplayName("handles zero")
+ void zeroValue() {
+ assertThat(processor.parseMemoryMb("0.0MB")).isEqualTo(0.0);
+ }
+
+ @Test
+ @DisplayName("returns 0.0 for null input")
+ void nullInput() {
+ assertThat(processor.parseMemoryMb(null)).isEqualTo(0.0);
+ }
+
+ @Test
+ @DisplayName("returns 0.0 for malformed input")
+ void malformedInput() {
+ assertThat(processor.parseMemoryMb("invalid")).isEqualTo(0.0);
+ }
+ }
+
+ // === parseRuntimeMs ===
+
+ @Nested
+ @DisplayName("parseRuntimeMs")
+ class ParseRuntimeMs {
+
+ @Test
+ @DisplayName("parses standard ms format")
+ void standardFormat() {
+ assertThat(processor.parseRuntimeMs("123ms")).isEqualTo(123L);
+ }
+
+ @Test
+ @DisplayName("returns 0 for null input")
+ void nullInput() {
+ assertThat(processor.parseRuntimeMs(null)).isEqualTo(0L);
+ }
+
+ @Test
+ @DisplayName("returns 0 for malformed input")
+ void malformedInput() {
+ assertThat(processor.parseRuntimeMs("invalid")).isEqualTo(0L);
+ }
+ }
+
+ // === Helper methods ===
+
+ private List buildTestCases(int count) {
+ java.util.ArrayList cases = new java.util.ArrayList<>();
+ for (int i = 0; i < count; i++) {
+ TestCase tc = new TestCase();
+ tc.setId(String.valueOf(1000 + i));
+ tc.setProblemId(100L);
+ tc.setTestOrder(i + 1);
+ tc.setInputText(String.valueOf(i));
+ tc.setOutputText(String.valueOf(i));
+ cases.add(tc);
+ }
+ return cases;
+ }
+
+ private RunResultDTO buildAcceptedResult(int caseCount) {
+ var caseResults = new java.util.ArrayList();
+ for (int i = 0; i < caseCount; i++) {
+ caseResults.add(buildCaseResult("Accepted", (50 + i * 10) + "ms", (4.0 + i) + "MB"));
+ }
+ return RunResultDTO.builder()
+ .verdict("Accepted")
+ .runtime((50 + (caseCount - 1) * 10) + "ms")
+ .memory((4.0 + (caseCount - 1)) + "MB")
+ .cases(caseResults)
+ .passedCases(caseCount)
+ .totalCases(caseCount)
+ .build();
+ }
+
+ private RunResultDTO buildWrongAnswerResult(int caseCount) {
+ var caseResults = new java.util.ArrayList();
+ for (int i = 0; i < caseCount; i++) {
+ String status = (i == caseCount - 1) ? "Wrong Answer" : "Accepted";
+ caseResults.add(buildCaseResult(status, "50ms", "4.0MB"));
+ }
+ return RunResultDTO.builder()
+ .verdict("Wrong Answer")
+ .runtime("50ms")
+ .memory("4.0MB")
+ .cases(caseResults)
+ .passedCases(caseCount - 1)
+ .totalCases(caseCount)
+ .build();
+ }
+
+ private RunResultDTO.RunCaseResult buildCaseResult(String status, String runtime, String memory) {
+ return RunResultDTO.RunCaseResult.builder()
+ .status(status)
+ .runtime(runtime)
+ .memory(memory)
+ .build();
+ }
+}
diff --git a/console/.omc/state/last-tool-error.json b/console/.omc/state/last-tool-error.json
new file mode 100644
index 000000000..ca997babc
--- /dev/null
+++ b/console/.omc/state/last-tool-error.json
@@ -0,0 +1,7 @@
+{
+ "tool_name": "Bash",
+ "tool_input_preview": "{\"command\":\"rtk ls db-manager/migrations/ && echo \\\"---\\\" && rtk git status db-manager/migrations/ --short\",\"description\":\"List all migrations and check git status\"}",
+ "error": "Exit code 2\nls: 无法访问 'db-manager/migrations/': 没有那个文件或目录",
+ "timestamp": "2026-04-18T11:21:26.462Z",
+ "retry_count": 2
+}
\ No newline at end of file
diff --git a/console/src/router/index.ts b/console/src/router/index.ts
index 67a3e80e8..f82b41325 100644
--- a/console/src/router/index.ts
+++ b/console/src/router/index.ts
@@ -299,6 +299,13 @@ const router = createRouter({
},
personalRoutes,
recommendationRoutes,
+ // Public user profile route
+ {
+ path: "/users/:id",
+ name: "user-profile",
+ component: () => import("@/views/users/UserProfileView.vue"),
+ meta: { requiresAuth: true },
+ },
],
});
diff --git a/console/src/views/users/UserProfileView.vue b/console/src/views/users/UserProfileView.vue
new file mode 100644
index 000000000..1d11d7a90
--- /dev/null
+++ b/console/src/views/users/UserProfileView.vue
@@ -0,0 +1,246 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
{{ profile.name || profile.username }}
+
@{{ profile.username }}
+
+
![]()
+
+ {{ (profile.name || profile.username).charAt(0).toUpperCase() }}
+
+
+
{{ profile.bio }}
+
+
+
+ {{ t("profile.joined", { date: new Date(profile.joined_at).toLocaleDateString() }) }}
+
+
+
+ {{ profile.location }}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {{ t("profile.progress.title") }}
+
+
+
+
+
+ {{ t("personal.stats.easy") }}
+
+ {{ stats.stats.Easy.count }} / {{ stats.stats.Easy.total }}
+
+
+
+
+
+
+
+
+ {{ t("personal.stats.medium") }}
+
+ {{ stats.stats.Medium.count }} / {{ stats.stats.Medium.total }}
+
+
+
+
+
+
+
+
+ {{ t("personal.stats.hard") }}
+
+ {{ stats.stats.Hard.count }} / {{ stats.stats.Hard.total }}
+
+
+
+
+
+
+
+
+
+ {{ t("personal.dashboard.heatmap.title") }}
+
+
+
+
+
+
+
+ {{ t("personal.dashboard.skills.title") }}
+
+
+
+
+