Feat: [FN-96][FN-97][FN-99][FN-110][FN-123] 그룹 초대 기능

src/main/java/project/flipnote/auth/service/AuthService.java

@@ -35,6 +35,7 @@
 import project.flipnote.auth.util.VerificationCodeGenerator;
 import project.flipnote.common.config.ClientProperties;
 import project.flipnote.common.dto.UserCreateCommand;
+import project.flipnote.common.event.UserRegisteredEvent;
 import project.flipnote.common.exception.BizException;
 import project.flipnote.common.security.dto.AuthPrinciple;
 import project.flipnote.common.security.jwt.JwtComponent;
@@ -77,6 +78,8 @@ public UserRegisterResponse register(UserRegisterRequest req) {
 			.build();
 		userAuthRepository.save(userAuth);
 
+		eventPublisher.publishEvent(new UserRegisteredEvent(userId, email));
+
 		return UserRegisterResponse.from(userId);
 	}
 

src/main/java/project/flipnote/common/config/SwaggerConfig.java

@@ -1,5 +1,6 @@
 package project.flipnote.common.config;
 
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
@@ -8,14 +9,18 @@
 import io.swagger.v3.oas.models.info.Info;
 import io.swagger.v3.oas.models.security.SecurityRequirement;
 import io.swagger.v3.oas.models.security.SecurityScheme;
-import project.flipnote.common.security.jwt.JwtConstants;
+import io.swagger.v3.oas.models.servers.Server;
 
 @Configuration
 public class SwaggerConfig {
 
+	@Value("${springdoc.server.url}")
+	private String serverUrl;
+
 	@Bean
 	public OpenAPI openApi() {
 		return new OpenAPI()
+			.addServersItem(new Server().url(serverUrl))
 			.addSecurityItem(
 				new SecurityRequirement()
 					.addList("access-token")

src/main/java/project/flipnote/common/event/UserRegisteredEvent.java

@@ -0,0 +1,7 @@
+package project.flipnote.common.event;
+
+public record UserRegisteredEvent(
+	Long userId,
+	String email
+) {
+}

src/main/java/project/flipnote/common/response/PageResponse.java

@@ -0,0 +1,32 @@
+package project.flipnote.common.response;
+
+import java.util.List;
+
+import org.springframework.data.domain.Page;
+
+public record PageResponse<T>(
+	List<T> content,
+	int page,
+	int size,
+	long totalElements,
+	int totalPages,
+	boolean first,
+	boolean last,
+	boolean hasNext,
+	boolean hasPrevious
+) {
+
+	public static <T> PageResponse<T> from(Page<T> page) {
+		return new PageResponse<>(
+			page.getContent(),
+			page.getNumber(),
+			page.getSize(),
+			page.getTotalElements(),
+			page.getTotalPages(),
+			page.isFirst(),
+			page.isLast(),
+			page.hasNext(),
+			page.hasPrevious()
+		);
+	}
+}

src/main/java/project/flipnote/common/security/exception/SecurityErrorCode.java

@@ -9,7 +9,7 @@
 @Getter
 @RequiredArgsConstructor
 public enum SecurityErrorCode implements ErrorCode {
-	TOKEN_EXPIRED(HttpStatus.UNAUTHORIZED.value(), "SECURITY_0021", "토큰이 만료되었습니다."),
+	TOKEN_EXPIRED(HttpStatus.UNAUTHORIZED.value(), "SECURITY_001", "토큰이 만료되었습니다."),
 	NOT_VALID_JWT_TOKEN(HttpStatus.UNAUTHORIZED.value(), "SECURITY_002", "올바르지 않은 토큰입니다."),
 	UNAUTHORIZED(HttpStatus.UNAUTHORIZED.value(), "SECURITY_003", "인증이 필요합니다."),
 	FORBIDDEN(HttpStatus.FORBIDDEN.value(), "SECURITY_004", "권한이 없습니다.");

src/main/java/project/flipnote/group/controller/GroupInvitationController.java

@@ -0,0 +1,63 @@
+package project.flipnote.group.controller;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PatchMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import project.flipnote.common.security.dto.AuthPrinciple;
+import project.flipnote.group.controller.docs.GroupInvitationControllerDocs;
+import project.flipnote.group.model.GroupInvitationCreateRequest;
+import project.flipnote.group.model.GroupInvitationCreateResponse;
+import project.flipnote.group.model.GroupInvitationRespondRequest;
+import project.flipnote.group.service.GroupInvitationService;
+
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/v1/groups/{groupId}/invitations")
+public class GroupInvitationController implements GroupInvitationControllerDocs {
+
+	private final GroupInvitationService groupInvitationService;
+
+	@PostMapping
+	public ResponseEntity<GroupInvitationCreateResponse> createGroupInvitation(
+		@PathVariable("groupId") Long groupId,
+		@Valid @RequestBody GroupInvitationCreateRequest req,
+		@AuthenticationPrincipal AuthPrinciple authPrinciple
+	) {
+		GroupInvitationCreateResponse res = groupInvitationService.createGroupInvitation(authPrinciple, groupId, req);
+
+		return ResponseEntity.status(HttpStatus.CREATED).body(res);
+	}
+
+	@DeleteMapping("/{invitationId}")
+	public ResponseEntity<Void> deleteGroupInvitation(
+		@PathVariable("groupId") Long groupId,
+		@PathVariable("invitationId") Long invitationId,
+		@AuthenticationPrincipal AuthPrinciple authPrinciple
+	) {
+		groupInvitationService.deleteGroupInvitation(authPrinciple.userId(), groupId, invitationId);
+
+		return ResponseEntity.ok().build();
+	}
+
+	@PatchMapping("/{invitationId}")
+	public ResponseEntity<Void> respondToGroupInvitation(
+		@PathVariable("groupId") Long groupId,
+		@PathVariable("invitationId") Long invitationId,
+		@Valid @RequestBody GroupInvitationRespondRequest req,
+		@AuthenticationPrincipal AuthPrinciple authPrinciple
+	) {
+		groupInvitationService.respondToGroupInvitation(authPrinciple.userId(), groupId, invitationId, req);
+
+		return ResponseEntity.ok().build();
+	}
+}

src/main/java/project/flipnote/group/controller/GroupInvitationQueryController.java

@@ -0,0 +1,51 @@
+package project.flipnote.group.controller;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import jakarta.validation.constraints.Min;
+import lombok.RequiredArgsConstructor;
+import project.flipnote.common.response.PageResponse;
+import project.flipnote.common.security.dto.AuthPrinciple;
+import project.flipnote.group.controller.docs.GroupInvitationQueryControllerDocs;
+import project.flipnote.group.model.IncomingGroupInvitationResponse;
+import project.flipnote.group.model.OutgoingGroupInvitationResponse;
+import project.flipnote.group.service.GroupInvitationService;
+
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/v1")
+public class GroupInvitationQueryController implements GroupInvitationQueryControllerDocs {
+
+	private final GroupInvitationService groupInvitationService;
+
+	@GetMapping("/groups/{groupId}/invitations")
+	public ResponseEntity<PageResponse<OutgoingGroupInvitationResponse>> getOutgoingInvitations(
+		@PathVariable("groupId") Long groupId,
+		@Min(0) @RequestParam(defaultValue = "0") int page,
+		@Min(1) @Min(30) @RequestParam(defaultValue = "20") int size,
+		@AuthenticationPrincipal AuthPrinciple authPrinciple
+	) {
+		PageResponse<OutgoingGroupInvitationResponse> res
+			= groupInvitationService.getOutgoingInvitations(authPrinciple.userId(), groupId, page, size);
+
+		return ResponseEntity.ok(res);
+	}
+
+	@GetMapping("/group-invitations")
+	public ResponseEntity<PageResponse<IncomingGroupInvitationResponse>> getIncomingInvitations(
+		@Min(0) @RequestParam(defaultValue = "0") int page,
+		@Min(1) @Min(30) @RequestParam(defaultValue = "20") int size,
+		@AuthenticationPrincipal AuthPrinciple authPrinciple
+	) {
+		PageResponse<IncomingGroupInvitationResponse> res
+			= groupInvitationService.getIncomingInvitations(authPrinciple.userId(), page, size);
+
+		return ResponseEntity.ok(res);
+	}
+}

src/main/java/project/flipnote/group/controller/docs/GroupInvitationControllerDocs.java

@@ -0,0 +1,28 @@
+package project.flipnote.group.controller.docs;
+
+import org.springframework.http.ResponseEntity;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.security.SecurityRequirement;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import project.flipnote.common.security.dto.AuthPrinciple;
+import project.flipnote.group.model.GroupInvitationCreateRequest;
+import project.flipnote.group.model.GroupInvitationCreateResponse;
+import project.flipnote.group.model.GroupInvitationRespondRequest;
+
+@Tag(name = "Group Invitation", description = "Group Invitation API")
+public interface GroupInvitationControllerDocs {
+
+	@Operation(summary = "그룹 초대", security = {@SecurityRequirement(name = "access-token")})
+	ResponseEntity<GroupInvitationCreateResponse> createGroupInvitation(
+		Long groupId, GroupInvitationCreateRequest req, AuthPrinciple authPrinciple
+	);
+
+	@Operation(summary = "그룹 초대 취소", security = {@SecurityRequirement(name = "access-token")})
+	ResponseEntity<Void> deleteGroupInvitation(Long groupId, Long invitationId, AuthPrinciple authPrinciple);
+
+	@Operation(summary = "그룹 초대 응답", security = {@SecurityRequirement(name = "access-token")})
+	ResponseEntity<Void> respondToGroupInvitation(
+		Long groupId, Long invitationId, GroupInvitationRespondRequest req, AuthPrinciple authPrinciple
+	);
+}

src/main/java/project/flipnote/group/controller/docs/GroupInvitationQueryControllerDocs.java

@@ -0,0 +1,30 @@
+package project.flipnote.group.controller.docs;
+
+import org.springframework.http.ResponseEntity;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.security.SecurityRequirement;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import project.flipnote.common.response.PageResponse;
+import project.flipnote.common.security.dto.AuthPrinciple;
+import project.flipnote.group.model.IncomingGroupInvitationResponse;
+import project.flipnote.group.model.OutgoingGroupInvitationResponse;
+
+@Tag(name = "Group Invitation Query", description = "Group Invitation Query API")
+public interface GroupInvitationQueryControllerDocs {
+
+	@Operation(summary = "그룹 초대 보낸 목록 조회", security = {@SecurityRequirement(name = "access-token")})
+	ResponseEntity<PageResponse<OutgoingGroupInvitationResponse>> getOutgoingInvitations(
+		Long groupId,
+		int page,
+		int size,
+		AuthPrinciple authPrinciple
+	);
+
+	@Operation(summary = "그룹 초대 받은 목록 조회", security = {@SecurityRequirement(name = "access-token")})
+	ResponseEntity<PageResponse<IncomingGroupInvitationResponse>> getIncomingInvitations(
+		int page,
+		int size,
+		AuthPrinciple authPrinciple
+	);
+}

src/main/java/project/flipnote/group/entity/Group.java

@@ -16,6 +16,8 @@
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import project.flipnote.common.entity.BaseEntity;
+import project.flipnote.common.exception.BizException;
+import project.flipnote.group.exception.GroupErrorCode;
 
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
@@ -67,4 +69,10 @@ private Group(
 		this.maxMember = maxMember;
 		this.imageUrl = imageUrl;
 	}
+
+	public void validateJoinable() {
+		if (maxMember < 1 || maxMember >= 100) {
+			throw new BizException(GroupErrorCode.INVALID_MAX_MEMBER);
+		}
+	}
 }

src/main/java/project/flipnote/group/entity/GroupInvitation.java

@@ -0,0 +1,70 @@
+package project.flipnote.group.entity;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Index;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import jakarta.persistence.UniqueConstraint;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import project.flipnote.common.entity.BaseEntity;
+
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Entity
+@Table(
+	name = "group_invitation",
+	indexes = {
+		@Index(name = "idx_group_invitee_user", columnList = "group_id, invitee_user_id, status"),
+		@Index(name = "idx_group_invitee_email", columnList = "group_id, invitee_email, status"),
+		@Index(name = "idx_invitee_user_status", columnList = "invitee_user_id, status"),
+		@Index(name = "idx_invitee_email_status", columnList = "invitee_email, status")
+	},
+	uniqueConstraints = {
+		@UniqueConstraint(name = "uq_group_invitee_user", columnNames = {"group_id", "invitee_user_id"}),
+		@UniqueConstraint(name = "uq_group_invitee_email", columnNames = {"group_id", "invitee_email"})
+	}
+)
+public class GroupInvitation extends BaseEntity {
+
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	private Long id;
+
+	@ManyToOne
+	@JoinColumn(name = "group_id", nullable = false)
+	private Group group;
+
+	@Column(nullable = false)
+	private Long inviterUserId;
+
+	private Long inviteeUserId;
+
+	private String inviteeEmail;
+
+	@Enumerated(EnumType.STRING)
+	@Column(nullable = false)
+	private GroupInvitationStatus status;
+
+	@Builder
+	public GroupInvitation(Group group, Long inviterUserId, Long inviteeUserId, String inviteeEmail) {
+		this.group = group;
+		this.inviterUserId = inviterUserId;
+		this.inviteeUserId = inviteeUserId;
+		this.inviteeEmail = inviteeEmail;
+		this.status = GroupInvitationStatus.PENDING;
+	}
+
+	public void respond(GroupInvitationStatus status) {
+		this.status = status;
+	}
+}

src/main/java/project/flipnote/group/entity/GroupInvitationStatus.java

@@ -0,0 +1,5 @@
+package project.flipnote.group.entity;
+
+public enum GroupInvitationStatus {
+	PENDING, ACCEPTED, REJECTED
+}

src/main/java/project/flipnote/group/exception/GroupErrorCode.java

@@ -11,7 +11,8 @@
 @RequiredArgsConstructor
 public enum GroupErrorCode implements ErrorCode {
 	GROUP_NOT_FOUND(HttpStatus.NOT_FOUND, "GROUP_002", "그룹이 존재하지 않습니다."),
-	INVALID_MAX_MEMBER(HttpStatus.BAD_REQUEST, "GROUP_001", "최대 인원 수는 1 이상 100 이하여야 합니다.");
+	INVALID_MAX_MEMBER(HttpStatus.BAD_REQUEST, "GROUP_001", "최대 인원 수는 1 이상 100 이하여야 합니다."),
+	USER_NOT_IN_GROUP(HttpStatus.NOT_FOUND, "GROUP_003", "그룹에 유저가 존재하지 않습니다.");
 
 	private final HttpStatus httpStatus;
 	private final String code;