Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -57,21 +57,27 @@ public void recordLog(String messageKey, Object... args) {
/**
* 사용자 안내: 메일과 Slack DM으로 보내고, 보냈다는 기록(본문 없음)을 알림 기록 채널에 남긴다.
* 메일이 실패하면 기록 대신 오류 채널로 알린다. DM은 메일 성패와 상관없이 보낸다.
*
* @return 메일이 나갔으면 true. 호출부가 실패를 보고 다시 보내거나 중복 표시를 풀 수 있게 한다.
*/
public void notifyUser(String username, String email, String subject, String body) {
safely("사용자 안내", () -> {
public boolean notifyUser(String username, String email, String subject, String body) {
try {
queue.dm(username, email, body);
mailUser(username, email, subject, body);
});
return mailUser(username, email, subject, body);
} catch (Exception e) {
log.error("사용자 안내 전송 실패", e);
return false;
}
}

/** 메일만 보내는 안내(접속 정보처럼 DM으로 보내지 않는 것). 발송 기록 규칙은 {@link #notifyUser}와 같다. */
public void mailUser(String username, String email, String subject, String body) {
public boolean mailUser(String username, String email, String subject, String body) {
if (mailer.send(email, subject, body)) {
queue.webhook(render("notification.monitor.log", username, email, subject), channels.notiWebhookUrl());
} else {
alertNeedsAction("notification.admin.mail-failed", EmailAddresses.mask(email));
return true;
}
alertNeedsAction("notification.admin.mail-failed", EmailAddresses.mask(email));
return false;
}

/**
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,39 @@
package DGU_AI_LAB.admin_be.domain.groups.controller;

import DGU_AI_LAB.admin_be.domain.groups.dto.response.GroupLeaveResponseDTO;
import DGU_AI_LAB.admin_be.domain.groups.service.GroupLeaveService;
import DGU_AI_LAB.admin_be.global.auth.CustomUserDetails;
import DGU_AI_LAB.admin_be.global.common.SuccessResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.*;

/** 관리자가 그룹 탈퇴 신청을 승인·거절한다. 승인하면 그룹 제거 작업이 등록된다. */
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/admin/group-leave-requests")
public class AdminGroupLeaveController {

private final GroupLeaveService groupLeaveService;

/** GET /api/admin/group-leave-requests — 승인을 기다리는 신청. */
@GetMapping
public ResponseEntity<SuccessResponse<?>> pending() {
return SuccessResponse.ok(groupLeaveService.pending().stream().map(GroupLeaveResponseDTO::fromEntity).toList());
}

@PostMapping("/{leaveRequestId}/approval")
public ResponseEntity<SuccessResponse<?>> approve(@PathVariable Long leaveRequestId,
@AuthenticationPrincipal CustomUserDetails principal) {
return SuccessResponse.accepted(GroupLeaveResponseDTO.fromEntity(
groupLeaveService.approve(leaveRequestId, principal.getUserId())));
}

@PostMapping("/{leaveRequestId}/rejection")
public ResponseEntity<SuccessResponse<?>> reject(@PathVariable Long leaveRequestId,
@AuthenticationPrincipal CustomUserDetails principal) {
return SuccessResponse.ok(GroupLeaveResponseDTO.fromEntity(
groupLeaveService.reject(leaveRequestId, principal.getUserId())));
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,34 @@
package DGU_AI_LAB.admin_be.domain.groups.controller;

import DGU_AI_LAB.admin_be.domain.groups.dto.response.GroupLeaveResponseDTO;
import DGU_AI_LAB.admin_be.domain.groups.service.GroupLeaveService;
import DGU_AI_LAB.admin_be.global.auth.CustomUserDetails;
import DGU_AI_LAB.admin_be.global.common.SuccessResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.*;

/** 사용자가 그룹 탈퇴를 신청하고 자기 신청을 본다. 승인·거절은 {@link AdminGroupLeaveController}. */
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/groups")
public class GroupLeaveController {

private final GroupLeaveService groupLeaveService;

/** POST /api/groups/{groupId}/leave-requests — 속한 그룹의 탈퇴를 신청한다(승인 대기). */
@PostMapping("/{groupId}/leave-requests")
public ResponseEntity<SuccessResponse<?>> request(@PathVariable Long groupId,
@AuthenticationPrincipal CustomUserDetails principal) {
return SuccessResponse.created(GroupLeaveResponseDTO.fromEntity(
groupLeaveService.request(principal.getUserId(), groupId)));
}

/** GET /api/groups/leave-requests/me — 내 탈퇴 신청 내역. */
@GetMapping("/leave-requests/me")
public ResponseEntity<SuccessResponse<?>> mine(@AuthenticationPrincipal CustomUserDetails principal) {
return SuccessResponse.ok(groupLeaveService.mine(principal.getUserId()).stream()
.map(GroupLeaveResponseDTO::fromEntity).toList());
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,38 @@
package DGU_AI_LAB.admin_be.domain.groups.dto.response;

import DGU_AI_LAB.admin_be.domain.groups.entity.GroupLeaveRequest;
import io.swagger.v3.oas.annotations.media.Schema;

import java.time.LocalDateTime;

@Schema(description = "그룹 탈퇴 신청")
public record GroupLeaveResponseDTO(
@Schema(description = "탈퇴 신청 번호", example = "3")
Long leaveRequestId,
@Schema(description = "PENDING(승인 대기) / APPROVED(승인 — 제거 작업 등록. 작업 결과는 그룹 작업 기록에서 본다) / REJECTED(거절)", example = "PENDING")
String status,
@Schema(description = "신청한 사용자 번호", example = "7")
Long userId,
@Schema(description = "신청한 사용자 이름", example = "홍길동")
String userName,
@Schema(description = "나가려는 그룹 번호", example = "12")
Long groupId,
@Schema(description = "나가려는 그룹 이름", example = "vision-lab")
String groupName,
@Schema(description = "신청 시각")
LocalDateTime createdAt,
@Schema(description = "승인·거절 시각. 대기 중이면 null")
LocalDateTime decidedAt
) {
public static GroupLeaveResponseDTO fromEntity(GroupLeaveRequest request) {
return new GroupLeaveResponseDTO(
request.getGroupLeaveRequestId(),
request.getStatus().name(),
request.getUser().getUserId(),
request.getUser().getName(),
request.getGroup().getGroupId(),
request.getGroup().getGroupName(),
request.getCreatedAt(),
request.getDecidedAt());
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,70 @@
package DGU_AI_LAB.admin_be.domain.groups.entity;

import DGU_AI_LAB.admin_be.domain.users.entity.User;
import DGU_AI_LAB.admin_be.global.common.BaseTimeEntity;
import jakarta.persistence.*;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;

import java.time.LocalDateTime;

/**
* 사용자가 낸 그룹 탈퇴 신청 한 건. 소속은 신청만으로 바뀌지 않는다 — 관리자가 승인하면 그룹 제거 작업이 등록되고
* 그 작업이 성공해야 소속이 빠진다({@code GroupOperationService#requestRemove}).
*/
@Entity
@Getter
@Table(name = "group_leave_requests")
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class GroupLeaveRequest extends BaseTimeEntity {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "group_leave_request_id")
private Long groupLeaveRequestId;

@Enumerated(EnumType.STRING)
@Column(name = "status", nullable = false, length = 20)
private GroupLeaveStatus status = GroupLeaveStatus.PENDING;

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "user_id", nullable = false)
private User user;

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "group_id", nullable = false)
private Group group;

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "decided_by")
private User decidedBy;

@Column(name = "decided_at")
private LocalDateTime decidedAt;

public static GroupLeaveRequest pending(User user, Group group) {
GroupLeaveRequest request = new GroupLeaveRequest();
request.user = user;
request.group = group;
return request;
}

public boolean isPending() {
return status == GroupLeaveStatus.PENDING;
}

public void approve(User admin) {
decide(GroupLeaveStatus.APPROVED, admin);
}

public void reject(User admin) {
decide(GroupLeaveStatus.REJECTED, admin);
}

private void decide(GroupLeaveStatus decision, User admin) {
this.status = decision;
this.decidedBy = admin;
this.decidedAt = LocalDateTime.now();
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,8 @@
package DGU_AI_LAB.admin_be.domain.groups.entity;

/** 그룹 탈퇴 신청의 상태. PENDING → APPROVED(제거 작업 등록) 또는 REJECTED. */
public enum GroupLeaveStatus {
PENDING,
APPROVED,
REJECTED
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,27 @@
package DGU_AI_LAB.admin_be.domain.groups.repository;

import DGU_AI_LAB.admin_be.domain.groups.entity.GroupLeaveRequest;
import DGU_AI_LAB.admin_be.domain.groups.entity.GroupLeaveStatus;
import jakarta.persistence.LockModeType;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Lock;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import java.util.List;
import java.util.Optional;

public interface GroupLeaveRequestRepository extends JpaRepository<GroupLeaveRequest, Long> {

@Lock(LockModeType.PESSIMISTIC_WRITE)
@Query("SELECT r FROM GroupLeaveRequest r WHERE r.groupLeaveRequestId = :id")
Optional<GroupLeaveRequest> findByIdForUpdate(@Param("id") Long id);

boolean existsByUser_UserIdAndGroup_GroupIdAndStatus(Long userId, Long groupId, GroupLeaveStatus status);

@Query("SELECT r FROM GroupLeaveRequest r JOIN FETCH r.user JOIN FETCH r.group WHERE r.status = :status ORDER BY r.createdAt")
List<GroupLeaveRequest> findAllByStatusWithUserAndGroup(@Param("status") GroupLeaveStatus status);

@Query("SELECT r FROM GroupLeaveRequest r JOIN FETCH r.user JOIN FETCH r.group WHERE r.user.userId = :userId ORDER BY r.createdAt DESC")
List<GroupLeaveRequest> findAllByUserWithGroup(@Param("userId") Long userId);
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,102 @@
package DGU_AI_LAB.admin_be.domain.groups.service;

import DGU_AI_LAB.admin_be.domain.groups.entity.Group;
import DGU_AI_LAB.admin_be.domain.groups.entity.GroupLeaveRequest;
import DGU_AI_LAB.admin_be.domain.groups.entity.GroupLeaveStatus;
import DGU_AI_LAB.admin_be.domain.groups.repository.GroupLeaveRequestRepository;
import DGU_AI_LAB.admin_be.domain.groups.repository.GroupRepository;
import DGU_AI_LAB.admin_be.domain.users.entity.User;
import DGU_AI_LAB.admin_be.domain.users.repository.UserRepository;
import DGU_AI_LAB.admin_be.error.ErrorCode;
import DGU_AI_LAB.admin_be.error.exception.BusinessException;
import DGU_AI_LAB.admin_be.error.exception.EntityNotFoundException;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.hibernate.Hibernate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
* 그룹 탈퇴 신청 → 관리자 승인. 승인하면 관리자가 직접 그룹에서 뺄 때와 같은 제거 작업({@link GroupOperationService#requestRemove})을
* 등록한다. 신청만으로는 소속이 바뀌지 않는다.
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class GroupLeaveService {

private final GroupLeaveRequestRepository leaveRepository;
private final GroupRepository groupRepository;
private final UserRepository userRepository;
private final GroupOperationService groupOperationService;

@Transactional
public GroupLeaveRequest request(Long userId, Long groupId) {
// 같은 사용자의 동시 신청이 중복 대기 신청을 만들지 못하게 사용자 행을 잠근다.
User user = userRepository.findByIdForUpdate(userId)
.orElseThrow(() -> new EntityNotFoundException(ErrorCode.USER_NOT_FOUND));
Group group = groupRepository.findById(groupId)
.orElseThrow(() -> new EntityNotFoundException(ErrorCode.GROUP_NOT_FOUND));
boolean member = user.getUserGroups().stream().anyMatch(ug -> ug.getGroup().getGroupId().equals(groupId));
if (!member) {
throw new BusinessException(ErrorCode.GROUP_LEAVE_NOT_MEMBER);
}
// 기본 그룹(계정 이름과 같은 그룹)은 어차피 제거할 수 없다 — 승인까지 기다리게 하지 않고 접수에서 거절한다.
if (group.getGroupName().equals(user.getUbuntuUsername())) {
throw new BusinessException(ErrorCode.PRIMARY_GROUP_REMOVAL);
}
if (leaveRepository.existsByUser_UserIdAndGroup_GroupIdAndStatus(userId, groupId, GroupLeaveStatus.PENDING)) {
throw new BusinessException(ErrorCode.GROUP_LEAVE_ALREADY_REQUESTED);
}
GroupLeaveRequest saved = leaveRepository.save(GroupLeaveRequest.pending(user, group));
log.info("[groupLeave] 탈퇴 신청: userId={}, groupId={}", userId, groupId);
return saved;
}

@Transactional(readOnly = true)
public List<GroupLeaveRequest> mine(Long userId) {
return leaveRepository.findAllByUserWithGroup(userId);
}

@Transactional(readOnly = true)
public List<GroupLeaveRequest> pending() {
return leaveRepository.findAllByStatusWithUserAndGroup(GroupLeaveStatus.PENDING);
}

/**
* 승인하고 제거 작업을 등록한다. 신청 행을 잠근 채 확인(대기) → 제거 작업 등록 → 승인 기록을 한 트랜잭션에서 한다.
* 등록이 실패하면 아무것도 바뀌지 않고 신청은 대기로 남는다. 등록 뒤 커밋이 실패하면 작업 기록(GroupOperation)도 함께
* 롤백돼 config-server 쪽 작업만 남고 폴러가 결과를 반영하지 못한다. 재승인하면 같은 제거 작업을 한 번 더 등록하므로
* 제거가 멱등이어야 한다(config-server 확인 필요, 미확인).
*/
@Transactional
public GroupLeaveRequest approve(Long leaveRequestId, Long adminId) {
GroupLeaveRequest request = lockPending(leaveRequestId);
groupOperationService.requestRemove(request.getUser().getUserId(), request.getGroup().getGroupId(), adminId);
request.approve(userRepository.getReferenceById(adminId));
log.info("[groupLeave] 탈퇴 승인: leaveRequestId={}, adminId={}", leaveRequestId, adminId);
return request;
}

@Transactional
public GroupLeaveRequest reject(Long leaveRequestId, Long adminId) {
GroupLeaveRequest request = lockPending(leaveRequestId);
request.reject(userRepository.getReferenceById(adminId));
log.info("[groupLeave] 탈퇴 거절: leaveRequestId={}, adminId={}", leaveRequestId, adminId);
return request;
}

private GroupLeaveRequest lockPending(Long leaveRequestId) {
GroupLeaveRequest request = leaveRepository.findByIdForUpdate(leaveRequestId)
.orElseThrow(() -> new EntityNotFoundException(ErrorCode.GROUP_LEAVE_REQUEST_NOT_FOUND));
if (!request.isPending()) {
throw new BusinessException(ErrorCode.INVALID_REQUEST_STATUS);
}
// 컨트롤러가 트랜잭션 밖에서 이름을 읽으므로(open-in-view 꺼짐) 지금 불러 둔다.
Hibernate.initialize(request.getUser());
Hibernate.initialize(request.getGroup());
return request;
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,32 @@
package DGU_AI_LAB.admin_be.domain.groups.service;

import DGU_AI_LAB.admin_be.domain.groups.entity.Group;
import DGU_AI_LAB.admin_be.domain.users.entity.User;
import DGU_AI_LAB.admin_be.error.ErrorCode;
import DGU_AI_LAB.admin_be.error.exception.BusinessException;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.Set;
import java.util.stream.Collectors;

/** 한 사람이 속할 수 있는 공용 그룹 수의 한도. 새로 소속이 늘어나는 경로(신청서·그룹 추가 변경 요청)가 같은 규칙을 쓴다. */
@Component
public class GroupMembershipPolicy {

static final int MAX_GROUPS_PER_USER = 5;

/**
* 지금 속한 그룹에 {@code groupsToJoin}을 더해도 한도 안인지 확인한다. 이미 속한 그룹은 새로 세지 않는다.
*
* @throws BusinessException 한도를 넘으면 GROUP_LIMIT_EXCEEDED
*/
public void requireRoomFor(User user, Collection<Group> groupsToJoin) {
Set<Long> current = user.getUserGroups().stream()
.map(ug -> ug.getGroup().getGroupId()).collect(Collectors.toSet());
long added = groupsToJoin.stream().map(Group::getGroupId).filter(id -> !current.contains(id)).distinct().count();
if (added > 0 && current.size() + added > MAX_GROUPS_PER_USER) {
throw new BusinessException(ErrorCode.GROUP_LIMIT_EXCEEDED);
}
}
}
Loading
Loading