package com.rongyichuang.activity.service;
|
|
import com.rongyichuang.activity.dto.ActivityInput;
|
import com.rongyichuang.activity.dto.ActivityJudgeInput;
|
import com.rongyichuang.activity.dto.ActivityJudgeResponse;
|
import com.rongyichuang.activity.dto.ActivityResponse;
|
import com.rongyichuang.activity.dto.ActivityStageInput;
|
import com.rongyichuang.activity.entity.Activity;
|
import com.rongyichuang.activity.entity.ActivityJudge;
|
import com.rongyichuang.activity.repository.ActivityJudgeRepository;
|
import com.rongyichuang.activity.repository.ActivityRepository;
|
import com.rongyichuang.judge.entity.Judge;
|
import com.rongyichuang.player.repository.ActivityPlayerRepository;
|
import com.rongyichuang.judge.repository.JudgeRepository;
|
import com.rongyichuang.common.dto.PageRequest;
|
import com.rongyichuang.common.dto.PageResponse;
|
import com.rongyichuang.rating.entity.RatingScheme;
|
import com.rongyichuang.rating.repository.RatingSchemeRepository;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.data.domain.Example;
|
import org.springframework.data.domain.ExampleMatcher;
|
import org.springframework.data.domain.Page;
|
import org.springframework.data.domain.Pageable;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.StringUtils;
|
|
import java.util.ArrayList;
|
import java.util.HashSet;
|
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
|
@Transactional
|
public class ActivityService {
|
|
@Autowired
|
private ActivityRepository activityRepository;
|
|
@Autowired
|
private ActivityJudgeRepository activityJudgeRepository;
|
|
@Autowired
|
private JudgeRepository judgeRepository;
|
|
@Autowired
|
private RatingSchemeRepository ratingSchemeRepository;
|
|
@Autowired
|
private ActivityPlayerRepository activityPlayerRepository;
|
|
/**
|
* 分页查询比赛列表
|
*/
|
public PageResponse<ActivityResponse> findActivities(PageRequest pageRequest, String name) {
|
Pageable pageable = pageRequest.toPageable();
|
Page<Activity> page;
|
|
if (StringUtils.hasText(name)) {
|
page = activityRepository.findByPidAndNameContainingOrderByCreateTimeDesc(0L, name, pageable);
|
} else {
|
// 查询所有主活动（pid = 0）
|
page = activityRepository.findByPidOrderByCreateTimeDesc(0L, pageable);
|
}
|
|
List<ActivityResponse> content = page.getContent().stream()
|
.map(activity -> {
|
ActivityResponse response = new ActivityResponse(activity);
|
// 设置参赛人数（只统计第一阶段的审核通过学员人数）
|
int playerCount = 0;
|
Activity firstStage = activityRepository.findFirstStageByActivityId(activity.getId());
|
if (firstStage != null) {
|
// 如果有第一阶段，统计第一阶段的审核通过人数
|
Long playerCountLong = activityPlayerRepository.countByStageIdAndState(firstStage.getId(), 1);
|
playerCount = playerCountLong != null ? playerCountLong.intValue() : 0;
|
} else {
|
// 如果没有阶段，统计活动本身的审核通过人数
|
Long playerCountLong = activityPlayerRepository.countByActivityIdAndState(activity.getId(), 1);
|
playerCount = playerCountLong != null ? playerCountLong.intValue() : 0;
|
}
|
response.setPlayerCount(playerCount);
|
return response;
|
})
|
.collect(Collectors.toList());
|
|
return new PageResponse<>(content, page.getTotalElements(), page.getNumber(), page.getSize());
|
}
|
|
/**
|
* 获取比赛详情
|
*/
|
public ActivityResponse findById(Long id) {
|
Optional<Activity> activityOpt = activityRepository.findById(id);
|
if (activityOpt.isPresent()) {
|
Activity activity = activityOpt.get();
|
ActivityResponse response = new ActivityResponse(activity);
|
|
// 设置参赛人数（审核通过的报名数量）
|
Long playerCountLong = activityPlayerRepository.countByActivityId(activity.getId());
|
int playerCount = playerCountLong != null ? playerCountLong.intValue() : 0;
|
response.setPlayerCount(playerCount);
|
|
// 如果是比赛，加载其阶段
|
if (activity.isMainActivity()) {
|
List<Activity> stages = activityRepository.findByPidAndStateOrderByCreateTimeAsc(id, 1);
|
List<ActivityResponse> stageResponses = stages.stream()
|
.map(stage -> {
|
ActivityResponse stageResponse = new ActivityResponse(stage);
|
// 设置阶段的参赛人数
|
Long stagePlayerCountLong = activityPlayerRepository.countByActivityId(stage.getId());
|
int stagePlayerCount = stagePlayerCountLong != null ? stagePlayerCountLong.intValue() : 0;
|
stageResponse.setPlayerCount(stagePlayerCount);
|
return stageResponse;
|
})
|
.collect(Collectors.toList());
|
response.setStages(stageResponses);
|
}
|
|
// 加载评委数据
|
List<ActivityJudgeResponse> judges = loadActivityJudges(id);
|
response.setJudges(judges);
|
|
return response;
|
}
|
return null;
|
}
|
|
/**
|
* 保存比赛（新增或编辑）
|
*/
|
public ActivityResponse saveActivity(ActivityInput input) {
|
Activity activity;
|
|
if (input.isNew()) {
|
// 新增比赛
|
activity = new Activity();
|
activity.setPid(input.getPid());
|
activity.setPath(generatePath(input.getPid()));
|
} else {
|
// 编辑比赛
|
Optional<Activity> existingOpt = activityRepository.findById(input.getId());
|
if (!existingOpt.isPresent()) {
|
throw new RuntimeException("比赛不存在");
|
}
|
activity = existingOpt.get();
|
}
|
|
// 设置基本信息
|
activity.setName(input.getName());
|
activity.setDescription(input.getDescription());
|
activity.setSignupDeadline(input.getSignupDeadline());
|
activity.setMatchTime(input.getMatchTime());
|
activity.setAddress(input.getAddress());
|
activity.setRatingSchemeId(input.getRatingSchemeId());
|
activity.setPlayerMax(input.getPlayerMax());
|
activity.setState(input.getState());
|
|
// 验证评分模板是否存在
|
if (input.getRatingSchemeId() != null) {
|
Optional<RatingScheme> schemeOpt = ratingSchemeRepository.findById(input.getRatingSchemeId());
|
if (!schemeOpt.isPresent()) {
|
throw new RuntimeException("评分模板不存在");
|
}
|
}
|
|
// 如果是比赛，验证必须至少有一个阶段
|
if (input.isMainActivity()) {
|
if (input.getStages() == null || input.getStages().isEmpty()) {
|
throw new RuntimeException("比赛必须至少有一个阶段");
|
}
|
|
// 验证阶段数量不超过5个
|
if (input.getStages().size() > 5) {
|
throw new RuntimeException("比赛阶段数量不能超过5个");
|
}
|
|
// 验证sort_order连续性
|
validateSortOrderContinuity(input.getStages());
|
}
|
|
// 保存比赛
|
activity = activityRepository.save(activity);
|
|
// 如果是比赛且有阶段信息，保存阶段
|
if (input.isMainActivity() && input.getStages() != null && !input.getStages().isEmpty()) {
|
saveActivityStages(activity.getId(), input.getStages());
|
}
|
|
// 如果是比赛且有评委信息，保存评委
|
if (input.isMainActivity() && input.getJudges() != null && !input.getJudges().isEmpty()) {
|
saveActivityJudges(activity.getId(), input.getJudges());
|
}
|
|
// 重新查询完整的数据（包含关联的stages）
|
return findById(activity.getId());
|
}
|
|
/**
|
* 保存比赛阶段
|
*/
|
private void saveActivityStages(Long activityId, List<ActivityStageInput> stageInputs) {
|
// 获取现有的所有阶段
|
List<Activity> existingStages = activityRepository.findByPidAndStateOrderByCreateTimeAsc(activityId, 1);
|
|
// 收集传入的阶段ID
|
List<Long> inputStageIds = stageInputs.stream()
|
.filter(input -> !input.isNew())
|
.map(ActivityStageInput::getId)
|
.collect(Collectors.toList());
|
|
// 删除不在传入列表中的现有阶段（软删除）
|
for (Activity existingStage : existingStages) {
|
if (!inputStageIds.contains(existingStage.getId())) {
|
existingStage.setState(0); // 软删除
|
activityRepository.save(existingStage);
|
}
|
}
|
|
// 获取比赛信息，用于继承报名截止时间和评分模板
|
Optional<Activity> activityOpt = activityRepository.findById(activityId);
|
if (!activityOpt.isPresent()) {
|
throw new RuntimeException("比赛不存在");
|
}
|
Activity activity = activityOpt.get();
|
|
// 处理传入的阶段（新增或更新）
|
for (ActivityStageInput stageInput : stageInputs) {
|
Activity stage;
|
|
if (stageInput.isNew()) {
|
// 新增阶段
|
stage = new Activity();
|
stage.setPid(activityId);
|
stage.setPath(generatePath(activityId));
|
} else {
|
// 编辑阶段
|
Optional<Activity> existingOpt = activityRepository.findById(stageInput.getId());
|
if (!existingOpt.isPresent()) {
|
continue; // 跳过不存在的阶段
|
}
|
stage = existingOpt.get();
|
}
|
|
// 设置阶段信息
|
stage.setName(stageInput.getName());
|
stage.setDescription(stageInput.getDescription());
|
stage.setMatchTime(stageInput.getMatchTime());
|
stage.setAddress(stageInput.getAddress());
|
stage.setPlayerMax(stageInput.getPlayerMax());
|
stage.setSortOrder(stageInput.getSortOrder());
|
stage.setState(stageInput.getState());
|
|
// 阶段继承比赛的报名截止时间
|
stage.setSignupDeadline(activity.getSignupDeadline());
|
|
// 阶段的评分模板：如果指定了则使用指定的，否则继承比赛的评分模板
|
if (stageInput.getRatingSchemeId() != null) {
|
stage.setRatingSchemeId(stageInput.getRatingSchemeId());
|
} else {
|
stage.setRatingSchemeId(activity.getRatingSchemeId());
|
}
|
|
activityRepository.save(stage);
|
}
|
}
|
|
/**
|
* 保存比赛评委
|
*/
|
private void saveActivityJudges(Long activityId, List<ActivityJudgeInput> judgeInputs) {
|
if (judgeInputs == null || judgeInputs.isEmpty()) {
|
return;
|
}
|
|
// 获取比赛的所有阶段（如果有的话）
|
List<Activity> stages = activityRepository.findByPidAndStateOrderByCreateTimeAsc(activityId, 1);
|
|
// 保存评委关联
|
for (ActivityJudgeInput judgeInput : judgeInputs) {
|
// 先删除该评委的现有关联
|
activityJudgeRepository.deleteByActivityIdAndJudgeId(activityId, judgeInput.getJudgeId());
|
|
if (judgeInput.getStageIds() == null || judgeInput.getStageIds().isEmpty()) {
|
// 如果没有指定阶段，创建关联到所有阶段（如果有阶段）或直接关联到比赛（如果没有阶段）
|
if (stages.isEmpty()) {
|
// 比赛没有阶段，直接关联到比赛（stage_id为null表示所有阶段）
|
ActivityJudge activityJudge = new ActivityJudge(activityId, judgeInput.getJudgeId(), null);
|
activityJudgeRepository.save(activityJudge);
|
} else {
|
// 为每个阶段创建关联
|
for (Activity stage : stages) {
|
ActivityJudge activityJudge = new ActivityJudge(activityId, judgeInput.getJudgeId(), stage.getId());
|
activityJudgeRepository.save(activityJudge);
|
}
|
}
|
} else {
|
// 为每个指定的阶段创建关联
|
for (Long stageId : judgeInput.getStageIds()) {
|
// 如果stageId等于当前比赛ID，表示评委负责整个比赛，stage_id设为null
|
Long actualStageId = stageId.equals(activityId) ? null : stageId;
|
ActivityJudge activityJudge = new ActivityJudge(activityId, judgeInput.getJudgeId(), actualStageId);
|
activityJudgeRepository.save(activityJudge);
|
}
|
}
|
}
|
}
|
|
/**
|
* 删除比赛
|
*/
|
public boolean deleteActivity(Long id) {
|
Optional<Activity> activityOpt = activityRepository.findById(id);
|
if (activityOpt.isPresent()) {
|
Activity activity = activityOpt.get();
|
|
// 如果是比赛，先删除其所有阶段
|
if (activity.isMainActivity()) {
|
List<Activity> stages = activityRepository.findByPidAndStateOrderByCreateTimeAsc(id, 1);
|
for (Activity stage : stages) {
|
stage.setState(0); // 软删除
|
activityRepository.save(stage);
|
}
|
}
|
|
// 软删除比赛
|
activity.setState(0);
|
activityRepository.save(activity);
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* 获取所有有效主比赛（用于下拉选择）
|
*/
|
public List<ActivityResponse> findAllActivitiesForSelection() {
|
// 获取所有状态为1的活动
|
List<Activity> allActivities = activityRepository.findByStateOrderByPidAscNameAsc(1);
|
|
// 过滤：只保留主比赛（pid=0）
|
List<Activity> filteredActivities = allActivities.stream()
|
.filter(activity -> activity.getPid() == 0)
|
.collect(Collectors.toList());
|
|
// 转换为ActivityResponse
|
List<ActivityResponse> result = filteredActivities.stream()
|
.map(activity -> {
|
ActivityResponse response = new ActivityResponse(activity);
|
// 设置参赛人数（所有阶段的报名数量总和）
|
Long playerCountLong = activityPlayerRepository.countByActivityId(activity.getId());
|
int playerCount = playerCountLong != null ? playerCountLong.intValue() : 0;
|
response.setPlayerCount(playerCount);
|
|
return response;
|
})
|
.sorted((a, b) -> a.getName().compareTo(b.getName()))
|
.collect(Collectors.toList());
|
|
return result;
|
}
|
|
/**
|
* 获取比赛的所有阶段
|
*/
|
public List<ActivityResponse> findStagesByActivityId(Long activityId) {
|
List<Activity> stages = activityRepository.findByPidAndStateOrderByCreateTimeAsc(activityId, 1);
|
return stages.stream()
|
.map(activity -> {
|
ActivityResponse response = new ActivityResponse(activity);
|
// 设置参赛人数（审核通过的报名数量）
|
Long playerCountLong = activityPlayerRepository.countByActivityId(activity.getId());
|
int playerCount = playerCountLong != null ? playerCountLong.intValue() : 0;
|
response.setPlayerCount(playerCount);
|
return response;
|
})
|
.collect(Collectors.toList());
|
}
|
|
/**
|
* 获取所有比赛阶段（用于评审页面下拉选择）
|
* 返回所有状态为1且pid>0的比赛阶段
|
*/
|
public List<ActivityResponse> findAllStagesForSelection() {
|
// 获取所有状态为1的活动
|
List<Activity> allActivities = activityRepository.findByStateOrderByPidAscNameAsc(1);
|
|
// 分离主比赛和阶段
|
Map<Long, Activity> parentActivitiesMap = allActivities.stream()
|
.filter(activity -> activity.getPid() == 0)
|
.collect(Collectors.toMap(Activity::getId, activity -> activity));
|
|
// 过滤：只保留比赛阶段（pid>0）
|
List<Activity> filteredStages = allActivities.stream()
|
.filter(activity -> activity.getPid() > 0)
|
.collect(Collectors.toList());
|
|
// 转换为ActivityResponse
|
List<ActivityResponse> result = filteredStages.stream()
|
.map(activity -> {
|
ActivityResponse response = new ActivityResponse(activity);
|
// 设置参赛人数（审核通过的报名数量）
|
Long playerCountLong = activityPlayerRepository.countByActivityId(activity.getId());
|
int playerCount = playerCountLong != null ? playerCountLong.intValue() : 0;
|
response.setPlayerCount(playerCount);
|
|
// 手动设置parent信息
|
Activity parentActivity = parentActivitiesMap.get(activity.getPid());
|
if (parentActivity != null) {
|
ActivityResponse parentResponse = new ActivityResponse(parentActivity);
|
response.setParent(parentResponse);
|
}
|
|
return response;
|
})
|
.sorted((a, b) -> {
|
// 先按父比赛ID排序，再按阶段名称排序
|
int pidCompare = Long.compare(a.getPid(), b.getPid());
|
if (pidCompare != 0) return pidCompare;
|
return a.getName().compareTo(b.getName());
|
})
|
.collect(Collectors.toList());
|
|
return result;
|
}
|
|
/**
|
* 统计比赛数量
|
*/
|
public long countActiveActivities() {
|
return activityRepository.countActiveActivities();
|
}
|
|
/**
|
* 获取进行中的比赛
|
*/
|
public List<ActivityResponse> findOngoingActivities() {
|
List<Activity> activities = activityRepository.findOngoingActivities();
|
return activities.stream()
|
.map(activity -> {
|
ActivityResponse response = new ActivityResponse(activity);
|
// 设置参赛人数（审核通过的报名数量）
|
Long playerCountLong = activityPlayerRepository.countByActivityId(activity.getId());
|
int playerCount = playerCountLong != null ? playerCountLong.intValue() : 0;
|
response.setPlayerCount(playerCount);
|
return response;
|
})
|
.collect(Collectors.toList());
|
}
|
|
/**
|
* 生成路径
|
*/
|
private String generatePath(Long pid) {
|
if (pid == 0) {
|
return "/";
|
} else {
|
Optional<Activity> parentOpt = activityRepository.findById(pid);
|
if (parentOpt.isPresent()) {
|
return parentOpt.get().getPath() + pid + "/";
|
}
|
return "/" + pid + "/";
|
}
|
}
|
|
/**
|
* 加载活动的评委数据
|
*/
|
private List<ActivityJudgeResponse> loadActivityJudges(Long activityId) {
|
// 查询活动的评委关联
|
List<ActivityJudge> activityJudges = activityJudgeRepository.findByActivityId(activityId);
|
|
// 按评委ID分组，收集每个评委负责的阶段
|
Map<Long, List<Long>> judgeStageMap = activityJudges.stream()
|
.collect(Collectors.groupingBy(
|
ActivityJudge::getJudgeId,
|
Collectors.mapping(
|
aj -> aj.getStageId() != null ? aj.getStageId() : activityId, // 如果stage_id为null，表示负责整个比赛，使用activityId
|
Collectors.toList()
|
)
|
));
|
|
// 查询评委详细信息并构建响应
|
List<ActivityJudgeResponse> result = new ArrayList<>();
|
for (Map.Entry<Long, List<Long>> entry : judgeStageMap.entrySet()) {
|
Long judgeId = entry.getKey();
|
List<Long> stageIds = entry.getValue();
|
|
Optional<Judge> judgeOpt = judgeRepository.findById(judgeId);
|
if (judgeOpt.isPresent()) {
|
Judge judge = judgeOpt.get();
|
ActivityJudgeResponse judgeResponse = new ActivityJudgeResponse(
|
judge.getId(),
|
judge.getName(),
|
judge.getPhone(),
|
judge.getDescription(),
|
stageIds
|
);
|
result.add(judgeResponse);
|
}
|
}
|
|
return result;
|
}
|
|
/**
|
* 验证阶段的sort_order连续性
|
*/
|
private void validateSortOrderContinuity(List<ActivityStageInput> stages) {
|
if (stages == null || stages.isEmpty()) {
|
return;
|
}
|
|
// 收集所有的sortOrder值
|
List<Integer> sortOrders = stages.stream()
|
.map(ActivityStageInput::getSortOrder)
|
.filter(Objects::nonNull)
|
.sorted()
|
.collect(Collectors.toList());
|
|
// 检查是否从1开始
|
if (sortOrders.isEmpty() || sortOrders.get(0) != 1) {
|
throw new RuntimeException("阶段排序必须从1开始");
|
}
|
|
// 检查连续性
|
for (int i = 0; i < sortOrders.size(); i++) {
|
if (sortOrders.get(i) != i + 1) {
|
throw new RuntimeException("阶段排序必须连续，不能跳跃（如：1,2,3...）");
|
}
|
}
|
|
// 检查是否有重复的sortOrder
|
Set<Integer> uniqueSortOrders = new HashSet<>(sortOrders);
|
if (uniqueSortOrders.size() != sortOrders.size()) {
|
throw new RuntimeException("阶段排序不能重复");
|
}
|
}
|
}
|
