[feat] 경기 날짜 기준 매칭 완료,실패 스케쥴러 생성

src/main/java/at/mateball/domain/group/core/GroupExecutorV3.java

@@ -0,0 +1,62 @@
+package at.mateball.domain.group.core;
+
+import at.mateball.domain.chatting.core.Chatting;
+import at.mateball.domain.chatting.core.service.ChattingV2Service;
+import at.mateball.domain.gameinformation.core.GameInformation;
+import at.mateball.domain.group.scheduler.MatchSchedule;
+import at.mateball.domain.group.scheduler.ScheduleType;
+import at.mateball.domain.group.scheduler.repository.SchedulerRepository;
+import at.mateball.domain.groupmember.GroupMemberStatus;
+import at.mateball.domain.groupmember.core.GroupMember;
+import at.mateball.domain.user.core.User;
+import at.mateball.exception.BusinessException;
+import at.mateball.exception.code.BusinessErrorCode;
+import jakarta.persistence.EntityManager;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+
+@Component
+public class GroupExecutorV3 {
+
+    private final EntityManager entityManager;
+    private final ChattingV2Service chattingV2Service;
+    private final SchedulerRepository schedulerRepository;
+
+    public GroupExecutorV3(EntityManager entityManager, ChattingV2Service chattingV2Service, SchedulerRepository schedulerRepository) {
+        this.entityManager = entityManager;
+        this.chattingV2Service = chattingV2Service;
+        this.schedulerRepository = schedulerRepository;
+    }
+
+    @Transactional
+    public Long createGroup(Long userId, Long gameId, boolean isGroup) {
+        User user = entityManager.find(User.class, userId);
+        if (user == null) {
+            throw new BusinessException(BusinessErrorCode.USER_NOT_FOUND);
+        }
+
+        GameInformation game = entityManager.find(GameInformation.class, gameId);
+        LocalDateTime gameDateTime = LocalDateTime.of(game.getGameDate(), game.getGameTime());
+
+        Chatting chatting = chattingV2Service.assignChatting();
+        if (chatting == null) {
+            throw new BusinessException(BusinessErrorCode.CHATTING_NOT_FOUND);
+        }
+
+        Group group = Group.create(user, game, isGroup);
+        group.assignChatting(chatting);
+
+        entityManager.persist(group);
+        entityManager.flush();
+
+        GroupMember leader = GroupMember.leader(user, group, GroupMemberStatus.PENDING_REQUEST.getValue());
+        entityManager.persist(leader);
+
+        schedulerRepository.save(new MatchSchedule(group, gameDateTime.minusMinutes(1), ScheduleType.FAIL));
+        schedulerRepository.save(new MatchSchedule(group, gameDateTime, ScheduleType.COMPLETE));
+
+        return group.getId();
+    }
+}

src/main/java/at/mateball/domain/group/core/GroupStatus.java

@@ -34,6 +34,14 @@ public static GroupStatus fromCode(String label) {
                 .orElseThrow(() -> new BusinessException(BusinessErrorCode.BAD_REQUEST_ENUM));
     }
 
+    public static String labelOf(int value) {
+        return Arrays.stream(values())
+                .filter(status -> status.value == value)
+                .map(status -> status.label)
+                .findFirst()
+                .orElseThrow(() -> new BusinessException(BusinessErrorCode.BAD_REQUEST_ENUM));
+    }
+
     public String toResponseLabel() {
         return switch (this) {
             case PENDING -> "그룹원 모집중";

src/main/java/at/mateball/domain/group/scheduler/GroupMatchCompleteService.java

@@ -0,0 +1,31 @@
+package at.mateball.domain.group.scheduler;
+
+import at.mateball.domain.group.core.Group;
+import at.mateball.domain.group.core.repository.GroupRepository;
+import at.mateball.domain.groupmember.core.repository.GroupMemberRepository;
+import at.mateball.exception.BusinessException;
+import at.mateball.exception.code.BusinessErrorCode;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@RequiredArgsConstructor
+public class GroupMatchCompleteService {
+    private static final int MIN_PARTICIPANT_FOR_COMPLETE = 2;
+
+    private final GroupRepository groupRepository;
+    private final GroupMemberRepository groupMemberRepository;
+
+    @Transactional
+    public void validateCompleteStatus(Long groupId) {
+        Group group = groupRepository.findById(groupId)
+                .orElseThrow(() -> new BusinessException(BusinessErrorCode.GROUP_NOT_FOUND));
+
+        int memberCount = groupMemberRepository.countGroupMember(groupId).count();
+
+        if ((group.isGroup() && memberCount >= MIN_PARTICIPANT_FOR_COMPLETE)) {
+            groupMemberRepository.updateAllStatusComplete(groupId);
+        }
+    }
+}

src/main/java/at/mateball/domain/group/scheduler/GroupMatchFailService.java

@@ -1,6 +1,7 @@
 package at.mateball.domain.group.scheduler;
 
 import at.mateball.domain.group.core.repository.GroupRepository;
+import at.mateball.domain.groupmember.core.repository.GroupMemberRepository;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -12,10 +13,14 @@
 @Service
 @Slf4j
 public class GroupMatchFailService {
+    private static final int MIN_PARTICIPANT_FOR_COMPLETE = 2;
+
     private final GroupRepository groupRepository;
+    private final GroupMemberRepository groupMemberRepository;
 
-    public GroupMatchFailService(GroupRepository groupRepository) {
+    public GroupMatchFailService(GroupRepository groupRepository, GroupMemberRepository groupMemberRepository) {
         this.groupRepository = groupRepository;
+        this.groupMemberRepository = groupMemberRepository;
     }
 
     @Transactional
@@ -44,4 +49,12 @@ private LocalDate calculateTargetDate(LocalDate today) {
 
         return today.plusDays(2);
     }
+
+    public void validateFailStatus(Long groupId) {
+        int participantCount = groupMemberRepository.countGroupMember(groupId).count();
+
+        if (participantCount < MIN_PARTICIPANT_FOR_COMPLETE) {
+            groupMemberRepository.updateAllStatusFail(groupId);
+        }
+    }
 }

src/main/java/at/mateball/domain/group/scheduler/MatchSchedule.java

@@ -0,0 +1,44 @@
+package at.mateball.domain.group.scheduler;
+
+import at.mateball.domain.group.core.Group;
+import jakarta.persistence.*;
+import lombok.Getter;
+
+import java.time.LocalDateTime;
+
+@Entity
+@Getter
+@Table(name = "match_schedule")
+public class MatchSchedule {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne(fetch = FetchType.LAZY, optional = false)
+    @JoinColumn(name = "group_id", nullable = false)
+    private Group group;
+
+    @Column(nullable = false)
+    private LocalDateTime executeTime;
+
+    @Column(nullable = false)
+    @Enumerated(EnumType.STRING)
+    private ScheduleType type;
+
+    @Column(nullable = false)
+    private boolean executed = false;
+
+    protected MatchSchedule() {
+    }
+
+    public MatchSchedule(Group group, LocalDateTime executeTime, ScheduleType type) {
+        this.group = group;
+        this.executeTime = executeTime;
+        this.type = type;
+        this.executed = false;
+    }
+
+    public void markExecuted() {
+        this.executed = true;
+    }
+}

src/main/java/at/mateball/domain/group/scheduler/MatchScheduler.java

@@ -0,0 +1,45 @@
+package at.mateball.domain.group.scheduler;
+
+import at.mateball.domain.group.scheduler.repository.SchedulerRepository;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Component
+@RequiredArgsConstructor
+@Slf4j
+public class MatchScheduler {
+
+    private final SchedulerRepository repository;
+    private final GroupMatchFailService matchFailService;
+    private final GroupMatchCompleteService matchCompleteService;
+
+    @Scheduled(cron = "0 */1 * * * *")
+    @Transactional
+    public void run() {
+        log.info("매칭 상태 업데이트 스케줄러 호출 완료");
+
+        LocalDateTime now = LocalDateTime.now();
+        List<MatchSchedule> targets = repository.findAllDueSchedules(now);
+
+        for (MatchSchedule s : targets) {
+            try {
+                if (s.getType().isFail()) {
+                    matchFailService.validateFailStatus(s.getGroup().getId());
+                } else {
+                    matchCompleteService.validateCompleteStatus(s.getGroup().getId());
+                }
+
+                s.markExecuted();
+
+            } catch (Exception e) {
+                log.error("스케줄 처리 실패 groupId={}", s.getGroup().getId(), e);
+            }
+        }
+    }
+}

src/main/java/at/mateball/domain/group/scheduler/ScheduleType.java

@@ -0,0 +1,15 @@
+package at.mateball.domain.group.scheduler;
+
+public enum ScheduleType {
+
+    FAIL,
+    COMPLETE;
+
+    public boolean isFail() {
+        return this == FAIL;
+    }
+
+    public boolean isComplete() {
+        return this == COMPLETE;
+    }
+}

src/main/java/at/mateball/domain/group/scheduler/repository/SchedulerCustom.java

@@ -0,0 +1,12 @@
+package at.mateball.domain.group.scheduler.repository;
+
+import at.mateball.domain.group.scheduler.MatchSchedule;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+public interface SchedulerCustom {
+    void save(MatchSchedule schedule);
+
+    List<MatchSchedule> findAllDueSchedules(LocalDateTime now);
+}

src/main/java/at/mateball/domain/group/scheduler/repository/SchedulerRepository.java

@@ -0,0 +1,9 @@
+package at.mateball.domain.group.scheduler.repository;
+
+import at.mateball.domain.group.core.Group;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface SchedulerRepository extends JpaRepository<Group, Long>, SchedulerCustom {
+}

src/main/java/at/mateball/domain/group/scheduler/repository/SchedulerRepositoryImpl.java

@@ -0,0 +1,37 @@
+package at.mateball.domain.group.scheduler.repository;
+
+import at.mateball.domain.group.scheduler.MatchSchedule;
+import at.mateball.domain.group.scheduler.QMatchSchedule;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import jakarta.persistence.EntityManager;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+public class SchedulerRepositoryImpl implements SchedulerCustom {
+    private final JPAQueryFactory queryFactory;
+    private final EntityManager em;
+
+    public SchedulerRepositoryImpl(JPAQueryFactory queryFactory, EntityManager em) {
+        this.queryFactory = queryFactory;
+        this.em = em;
+    }
+
+    @Override
+    public void save(MatchSchedule schedule) {
+        em.persist(schedule);
+    }
+
+    @Override
+    public List<MatchSchedule> findAllDueSchedules(LocalDateTime now) {
+        QMatchSchedule matchSchedule = QMatchSchedule.matchSchedule;
+
+        return queryFactory
+                .selectFrom(matchSchedule)
+                .where(
+                        matchSchedule.executed.isFalse(),
+                        matchSchedule.executeTime.loe(now)
+                )
+                .fetch();
+    }
+}

src/main/java/at/mateball/domain/groupmember/GroupMemberStatus.java

@@ -30,6 +30,14 @@ public static GroupMemberStatus from(int value) {
                 .orElseThrow(() -> new BusinessException(BusinessErrorCode.BAD_REQUEST_ENUM));
     }
 
+    public static String labelOf(int value) {
+        return Arrays.stream(values())
+                .filter(status -> status.value == value)
+                .map(status -> status.label)
+                .findFirst()
+                .orElseThrow(() -> new BusinessException(BusinessErrorCode.BAD_REQUEST_ENUM));
+    }
+
     public String toResponseLabel() {
         return switch (this) {
             case AWAITING_APPROVAL -> "수락 대기 중";

src/main/java/at/mateball/domain/groupmember/core/repository/querydsl/GroupMemberRepositoryCustom.java

@@ -80,4 +80,9 @@ public interface GroupMemberRepositoryCustom {
 
     Optional<Long> findApprovedRequesterUserId(Long groupId);
 
-    Optional<Long> findMatchedRequesterUserId(Long groupId);}
+    Optional<Long> findMatchedRequesterUserId(Long groupId);
+
+    void updateAllStatusFail(Long groupId);
+
+    void updateAllStatusComplete(Long groupId);
+}

src/main/java/at/mateball/domain/groupmember/core/repository/querydsl/GroupMemberRepositoryImpl.java

@@ -841,4 +841,34 @@ public Optional<Long> findMatchedRequesterUserId(Long groupId) {
 
         return Optional.ofNullable(requesterId);
     }
+
+    @Override
+    public void updateAllStatusFail(Long groupId){
+        queryFactory
+                .update(groupMember)
+                .set(groupMember.status, GroupMemberStatus.MATCH_FAILED.getValue())
+                .where(groupMember.group.id.eq(groupId))
+                .execute();
+
+        queryFactory
+                .update(group)
+                .set(group.status, GroupStatus.FAILED.getValue())
+                .where(group.id.eq(groupId))
+                .execute();
+    }
+
+    @Override
+    public void updateAllStatusComplete(Long groupId){
+        queryFactory
+                .update(groupMember)
+                .set(groupMember.status, GroupMemberStatus.MATCHED.getValue())
+                .where(groupMember.group.id.eq(groupId))
+                .execute();
+
+        queryFactory
+                .update(group)
+                .set(group.status, GroupStatus.COMPLETED.getValue())
+                .where(group.id.eq(groupId))
+                .execute();
+    }
 }