package com.rongyichuang.player.service;
|
|
import com.rongyichuang.activity.entity.Activity;
|
import com.rongyichuang.activity.entity.ActivityPlayerRating;
|
import com.rongyichuang.activity.repository.ActivityPlayerRatingRepository;
|
import com.rongyichuang.activity.repository.ActivityRepository;
|
import com.rongyichuang.judge.entity.Judge;
|
import com.rongyichuang.judge.repository.JudgeRepository;
|
import com.rongyichuang.player.dto.response.ProjectStageTimelineItemResponse;
|
import com.rongyichuang.player.dto.response.ProjectStageTimelineResponse;
|
import com.rongyichuang.player.dto.response.StageJudgeRatingDetailResponse;
|
import com.rongyichuang.player.dto.response.StageJudgeRatingItemResponse;
|
import com.rongyichuang.player.entity.ActivityPlayer;
|
import com.rongyichuang.player.repository.ActivityPlayerRepository;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.stereotype.Service;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.Comparator;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Optional;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
/**
|
* 项目阶段评分相关服务
|
*/
|
@Service
|
public class ProjectStageRatingService {
|
|
private static final Logger log = LoggerFactory.getLogger(ProjectStageRatingService.class);
|
|
private static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
|
|
private final ActivityPlayerRepository activityPlayerRepository;
|
private final ActivityRepository activityRepository;
|
private final ActivityPlayerRatingRepository activityPlayerRatingRepository;
|
private final JudgeRepository judgeRepository;
|
|
public ProjectStageRatingService(ActivityPlayerRepository activityPlayerRepository,
|
ActivityRepository activityRepository,
|
ActivityPlayerRatingRepository activityPlayerRatingRepository,
|
JudgeRepository judgeRepository) {
|
this.activityPlayerRepository = activityPlayerRepository;
|
this.activityRepository = activityRepository;
|
this.activityPlayerRatingRepository = activityPlayerRatingRepository;
|
this.judgeRepository = judgeRepository;
|
}
|
|
/**
|
* 获取项目在各阶段的时间轴与评分概况
|
*/
|
public ProjectStageTimelineResponse getProjectStageTimeline(Long activityPlayerId) {
|
ActivityPlayer current = activityPlayerRepository.findById(activityPlayerId)
|
.orElseThrow(() -> new IllegalArgumentException("未找到参赛记录，ID: " + activityPlayerId));
|
|
Long activityId = current.getActivityId();
|
Long playerId = current.getPlayerId();
|
|
ProjectStageTimelineResponse response = new ProjectStageTimelineResponse();
|
response.setActivityId(activityId);
|
|
Activity activity = activityRepository.findActivityById(activityId);
|
if (activity != null) {
|
response.setActivityName(activity.getName());
|
}
|
|
List<Activity> stages = new ArrayList<>(activityRepository.findByPidAndStateOrderBySortOrderAsc(activityId, 1));
|
|
Map<Long, ActivityPlayer> stagePlayerMap = activityPlayerRepository
|
.findByActivityIdAndPlayerIdOrderByCreateTimeDesc(activityId, playerId)
|
.stream()
|
.filter(ap -> ap.getStageId() != null)
|
.collect(Collectors.toMap(ActivityPlayer::getStageId, ap -> ap, (existing, replacement) -> existing));
|
|
// 确保当前阶段包含在时间轴中
|
if (current.getStageId() != null && !stagePlayerMap.containsKey(current.getStageId())) {
|
stagePlayerMap.put(current.getStageId(), current);
|
}
|
|
// 如果阶段列表中缺少已参赛阶段，补全它们
|
Set<Long> stageIdsInList = stages.stream().map(Activity::getId).collect(Collectors.toSet());
|
for (Long stageId : stagePlayerMap.keySet()) {
|
if (!stageIdsInList.contains(stageId)) {
|
Activity stage = activityRepository.findActivityById(stageId);
|
if (stage != null) {
|
stages.add(stage);
|
stageIdsInList.add(stageId);
|
}
|
}
|
}
|
|
// 按 sortOrder 及创建时间排序，确保展示顺序
|
stages.sort(Comparator
|
.comparing((Activity stage) -> Optional.ofNullable(stage.getSortOrder()).orElse(Integer.MAX_VALUE))
|
.thenComparing(Activity::getId));
|
|
List<ProjectStageTimelineItemResponse> items = new ArrayList<>();
|
for (Activity stage : stages) {
|
ProjectStageTimelineItemResponse item = new ProjectStageTimelineItemResponse();
|
item.setStageId(stage.getId());
|
item.setStageName(stage.getName());
|
item.setMatchTime(formatDateTime(stage.getMatchTime()));
|
item.setSortOrder(stage.getSortOrder());
|
|
ActivityPlayer stagePlayer = stagePlayerMap.get(stage.getId());
|
boolean participated = stagePlayer != null;
|
item.setParticipated(participated);
|
|
if (participated) {
|
item.setActivityPlayerId(stagePlayer.getId());
|
applyRatingMetrics(item, stagePlayer.getId());
|
} else {
|
item.setHasRating(false);
|
item.setRatingCount(0);
|
}
|
|
items.add(item);
|
}
|
|
response.setStages(items);
|
return response;
|
}
|
|
/**
|
* 获取指定阶段的评委评分详情
|
*/
|
public StageJudgeRatingDetailResponse getStageJudgeRatings(Long activityPlayerId) {
|
ActivityPlayer stagePlayer = activityPlayerRepository.findById(activityPlayerId)
|
.orElseThrow(() -> new IllegalArgumentException("未找到参赛记录，ID: " + activityPlayerId));
|
|
StageJudgeRatingDetailResponse response = new StageJudgeRatingDetailResponse();
|
response.setActivityPlayerId(activityPlayerId);
|
|
Activity stage = null;
|
if (stagePlayer.getStageId() != null) {
|
stage = activityRepository.findActivityById(stagePlayer.getStageId());
|
}
|
|
if (stage != null) {
|
response.setStageId(stage.getId());
|
response.setStageName(stage.getName());
|
response.setMatchTime(formatDateTime(stage.getMatchTime()));
|
} else {
|
response.setStageId(stagePlayer.getStageId());
|
response.setStageName("阶段信息缺失");
|
}
|
|
List<ActivityPlayerRating> ratings = activityPlayerRatingRepository.findByActivityPlayerId(activityPlayerId);
|
Map<Long, ActivityPlayerRating> latestRatingByJudge = new HashMap<>();
|
|
for (ActivityPlayerRating rating : ratings) {
|
Long judgeId = rating.getJudgeId();
|
if (judgeId == null) {
|
continue;
|
}
|
ActivityPlayerRating existing = latestRatingByJudge.get(judgeId);
|
if (existing == null) {
|
latestRatingByJudge.put(judgeId, rating);
|
} else {
|
LocalDateTime existingTime = existing.getUpdateTime();
|
LocalDateTime currentTime = rating.getUpdateTime();
|
if (existingTime == null || (currentTime != null && currentTime.isAfter(existingTime))) {
|
latestRatingByJudge.put(judgeId, rating);
|
}
|
}
|
}
|
|
Collection<ActivityPlayerRating> effectiveRatings = latestRatingByJudge.values();
|
List<BigDecimal> validScores = effectiveRatings.stream()
|
.map(ActivityPlayerRating::getTotalScore)
|
.filter(Objects::nonNull)
|
.collect(Collectors.toList());
|
|
int ratingCount = validScores.size();
|
response.setRatingCount(ratingCount);
|
if (ratingCount > 0) {
|
BigDecimal sum = validScores.stream().reduce(BigDecimal.ZERO, BigDecimal::add);
|
BigDecimal avg = sum.divide(BigDecimal.valueOf(ratingCount), 2, RoundingMode.HALF_UP);
|
response.setAverageScore(avg.doubleValue());
|
}
|
|
if (!effectiveRatings.isEmpty()) {
|
Set<Long> judgeIds = effectiveRatings.stream()
|
.map(ActivityPlayerRating::getJudgeId)
|
.filter(Objects::nonNull)
|
.collect(Collectors.toSet());
|
|
Map<Long, String> judgeNameMap = new HashMap<>();
|
if (!judgeIds.isEmpty()) {
|
List<Judge> judges = judgeRepository.findAllById(judgeIds);
|
for (Judge judge : judges) {
|
judgeNameMap.put(judge.getId(), judge.getName());
|
}
|
}
|
|
List<StageJudgeRatingItemResponse> judgeItems = effectiveRatings.stream()
|
.sorted(Comparator.comparing(ActivityPlayerRating::getUpdateTime, Comparator.nullsLast(LocalDateTime::compareTo)).reversed())
|
.map(rating -> {
|
StageJudgeRatingItemResponse item = new StageJudgeRatingItemResponse();
|
Long judgeId = rating.getJudgeId();
|
item.setJudgeId(judgeId);
|
item.setJudgeName(judgeNameMap.getOrDefault(judgeId, "未知评委"));
|
if (rating.getTotalScore() != null) {
|
item.setTotalScore(rating.getTotalScore().doubleValue());
|
}
|
item.setFeedback(rating.getFeedback());
|
item.setRatingTime(formatDateTime(rating.getUpdateTime()));
|
return item;
|
})
|
.collect(Collectors.toList());
|
|
response.setJudgeRatings(judgeItems);
|
}
|
|
return response;
|
}
|
|
private void applyRatingMetrics(ProjectStageTimelineItemResponse item, Long stageActivityPlayerId) {
|
List<ActivityPlayerRating> ratings = activityPlayerRatingRepository
|
.findCompletedRatingsByActivityPlayerId(stageActivityPlayerId);
|
|
List<BigDecimal> validScores = ratings.stream()
|
.map(ActivityPlayerRating::getTotalScore)
|
.filter(Objects::nonNull)
|
.collect(Collectors.toList());
|
|
int ratingCount = validScores.size();
|
item.setRatingCount(ratingCount);
|
item.setHasRating(ratingCount > 0);
|
|
if (ratingCount > 0) {
|
BigDecimal sum = validScores.stream().reduce(BigDecimal.ZERO, BigDecimal::add);
|
BigDecimal avg = sum.divide(BigDecimal.valueOf(ratingCount), 2, RoundingMode.HALF_UP);
|
item.setAverageScore(avg.doubleValue());
|
}
|
|
ratings.stream()
|
.map(ActivityPlayerRating::getUpdateTime)
|
.filter(Objects::nonNull)
|
.max(LocalDateTime::compareTo)
|
.ifPresent(time -> item.setLatestRatingTime(formatDateTime(time)));
|
}
|
|
private String formatDateTime(LocalDateTime time) {
|
if (time == null) {
|
return null;
|
}
|
return DATE_TIME_FORMATTER.format(time);
|
}
|
}
|
