shared-dg05-dodari/kt-event-marketing
7
0
Fork 0
mirror of https://github.com/ktds-dg0501/kt-event-marketing.git synced 2025-12-06 08:46:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'develop' into feature/analytics

Browse Source
This commit is contained in:
Hyowon Yang 2025-10-27 15:10:31 +09:00 committed by GitHub
commit 9b247ca058
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
179 changed files with 12989 additions and 495 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
.DS_Store vendored
View File

Binary file not shown.

28
.claude/settings.local.json
View File

@ -21,6 +21,34 @@
"Bash(./gradlew analytics-service:compileJava:*)",
"Bash(python -m json.tool:*)",
"Bash(powershell:*)"
"Bash(./gradlew participation-service:compileJava:*)",
"Bash(find:*)",
"Bash(netstat:*)",
"Bash(findstr:*)",
"Bash(docker-compose up:*)",
"Bash(docker --version:*)",
"Bash(timeout 60 bash:*)",
"Bash(docker ps:*)",
"Bash(docker exec:*)",
"Bash(docker-compose down:*)",
"Bash(git rm:*)",
"Bash(git restore:*)",
"Bash(./gradlew participation-service:test:*)",
"Bash(timeout 30 bash:*)",
"Bash(helm list:*)",
"Bash(helm upgrade:*)",
"Bash(helm repo add:*)",
"Bash(helm repo update:*)",
"Bash(kubectl get:*)",
"Bash(python3:*)",
"Bash(timeout 120 bash -c 'while true; do sleep 5; kubectl get pods -n kt-event-marketing | grep kafka | grep -v Running && continue; echo \"\"\"\"All Kafka pods are Running!\"\"\"\"; break; done')",
"Bash(kubectl delete:*)",
"Bash(kubectl logs:*)",
"Bash(kubectl describe:*)",
"Bash(kubectl exec:*)",
"mcp__context7__resolve-library-id",
"mcp__context7__get-library-docs",
"Bash(python -m json.tool:*)"
],
"deny": [],
"ask": []

15
.gitignore vendored
View File

@ -20,6 +20,8 @@ Thumbs.db
dist/
build/
*.log
.gradle/
logs/
# Gradle
.gradle/
@ -38,3 +40,16 @@ logs/
tmp/
temp/
*.tmp
# Kubernetes Secrets (민감한 정보 포함)
k8s/**/secret.yaml
k8s/**/*-secret.yaml
k8s/**/*-prod.yaml
k8s/**/*-dev.yaml
k8s/**/*-local.yaml
# IntelliJ 실행 프로파일 (민감한 환경 변수 포함 가능)
.run/*.run.xml
# Gradle (로컬 환경 설정)
gradle.properties

27
.run/EventServiceApplication.run.xml Normal file
View File

@ -0,0 +1,27 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="EventServiceApplication" type="SpringBootApplicationConfigurationType" factoryName="Spring Boot" folderName="Event Service">
<option name="ACTIVE_PROFILES" />
<option name="ENABLE_LAUNCH_OPTIMIZATION" value="true" />
<envs>
<env name="DB_HOST" value="20.249.177.232" />
<env name="DB_PORT" value="5432" />
<env name="DB_NAME" value="eventdb" />
<env name="DB_USERNAME" value="eventuser" />
<env name="DB_PASSWORD" value="Hi5Jessica!" />
<env name="REDIS_HOST" value="localhost" />
<env name="REDIS_PORT" value="6379" />
<env name="REDIS_PASSWORD" value="" />
<env name="KAFKA_BOOTSTRAP_SERVERS" value="localhost:9092" />
<env name="SERVER_PORT" value="8081" />
<env name="DDL_AUTO" value="update" />
<env name="LOG_LEVEL" value="DEBUG" />
<env name="SQL_LOG_LEVEL" value="DEBUG" />
<env name="DISTRIBUTION_SERVICE_URL" value="http://localhost:8084" />
</envs>
<module name="kt-event-marketing.event-service.main" />
<option name="SPRING_BOOT_MAIN_CLASS" value="com.kt.event.eventservice.EventServiceApplication" />
<method v="2">
<option name="Make" enabled="true" />
</method>
</configuration>
</component>

69
.run/ParticipationServiceApplication.run.xml Normal file
View File

@ -0,0 +1,69 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="ParticipationServiceApplication" type="GradleRunConfiguration" factoryName="Gradle">
<ExternalSystemSettings>
<option name="env">
<map>
<!-- 서버 설정 -->
<entry key="SERVER_PORT" value="8084" />
<!-- 데이터베이스 설정 -->
<entry key="DB_HOST" value="4.230.72.147" />
<entry key="DB_PORT" value="5432" />
<entry key="DB_NAME" value="participationdb" />
<entry key="DB_USERNAME" value="eventuser" />
<entry key="DB_PASSWORD" value="Hi5Jessica!" />
<!-- JPA 설정 -->
<entry key="DDL_AUTO" value="none" />
<entry key="SHOW_SQL" value="true" />
<!-- Redis 설정 -->
<entry key="REDIS_HOST" value="20.214.210.71" />
<entry key="REDIS_PORT" value="6379" />
<entry key="REDIS_PASSWORD" value="Hi5Jessica!" />
<!-- Kafka 설정 -->
<entry key="KAFKA_BOOTSTRAP_SERVERS" value="20.249.182.13:9095,4.217.131.59:9095" />
<!-- JWT 설정 -->
<entry key="JWT_SECRET" value="kt-event-marketing-secret-key-for-development-only-change-in-production" />
<entry key="JWT_EXPIRATION" value="86400000" />
<!-- 로깅 설정 -->
<entry key="LOG_LEVEL" value="INFO" />
<entry key="LOG_FILE" value="logs/participation-service.log" />
</map>
</option>
<option name="executionName" />
<option name="externalProjectPath" value="$PROJECT_DIR$" />
<option name="externalSystemIdString" value="GRADLE" />
<option name="scriptParameters" value="" />
<option name="taskDescriptions">
<list />
</option>
<option name="taskNames">
<list>
<option value="participation-service:bootRun" />
</list>
</option>
<option name="vmOptions" />
</ExternalSystemSettings>
<ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
<ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
<EXTENSION ID="com.intellij.execution.ExternalSystemRunConfigurationJavaExtension">
<extension name="net.ashald.envfile">
<option name="IS_ENABLED" value="false" />
<option name="IS_SUBST" value="false" />
<option name="IS_PATH_MACRO_SUPPORTED" value="false" />
<option name="IS_IGNORE_MISSING_FILES" value="false" />
<option name="IS_ENABLE_EXPERIMENTAL_INTEGRATIONS" value="false" />
<ENTRIES>
<ENTRY IS_ENABLED="true" PARSER="runconfig" IS_EXECUTABLE="false" />
</ENTRIES>
</extension>
</EXTENSION>
<DebugAllEnabled>false</DebugAllEnabled>
<RunAsTest>false</RunAsTest>
<method v="2" />
</configuration>
</component>

3
.vscode/settings.json vendored
View File

@ -1,3 +0,0 @@
{
"liveServer.settings.port": 5501
}

53
backing-service/docker-compose.yml Normal file
View File

@ -0,0 +1,53 @@
version: '3.8'
services:
# PostgreSQL - Participation Service
postgres-participation:
image: postgres:15-alpine
container_name: participation-db
environment:
POSTGRES_DB: participation_db
POSTGRES_USER: postgres
POSTGRES_PASSWORD: postgres
ports:
- "5432:5432"
volumes:
- postgres-participation-data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U postgres"]
interval: 10s
timeout: 5s
retries: 5
# Kafka
zookeeper:
image: confluentinc/cp-zookeeper:7.5.0
container_name: zookeeper
environment:
ZOOKEEPER_CLIENT_PORT: 2181
ZOOKEEPER_TICK_TIME: 2000
ports:
- "2181:2181"
kafka:
image: confluentinc/cp-kafka:7.5.0
container_name: kafka
depends_on:
- zookeeper
ports:
- "9092:9092"
environment:
KAFKA_BROKER_ID: 1
KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092
KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
healthcheck:
test: ["CMD-SHELL", "kafka-broker-api-versions --bootstrap-server localhost:9092"]
interval: 10s
timeout: 10s
retries: 5
volumes:
postgres-participation-data:

2
backing-service/install/postgres/values-user.yaml
View File

@ -29,6 +29,8 @@ primary:
# 성능 최적화 설정
extraEnvVars:
- name: POSTGRESQL_READ_ONLY_MODE
value: "no"
- name: POSTGRESQL_SHARED_BUFFERS
value: "1GB"
- name: POSTGRESQL_EFFECTIVE_CACHE_SIZE

0
claude/check-mermaid.sh Executable file → Normal file
View File

9
claude/make-run-profile.md
View File

@ -1,4 +1,7 @@
# 서비스실행프로파일작성가이드
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0# 서비스실행파일작성가이드
[요청사항]
- <수행원칙>을 준용하여 수행
@ -148,7 +151,8 @@
<option name="IS_ENABLED" value="false" />
<option name="IS_SUBST" value="false" />
<option name="IS_PATH_MACRO_SUPPORTED" value="false" />
<option name="IS_IGNORE_MISSING_FILES" value="false" />
<option name="IS_IGNORE_MISSING_FILES" value="false
100 9115 100 9115 0 0 28105 0 --:--:-- --:--:-- --:--:-- 28219" />
<option name="IS_ENABLE_EXPERIMENTAL_INTEGRATIONS" value="false" />
<ENTRIES>
<ENTRY IS_ENABLED="true" PARSER="runconfig" IS_EXECUTABLE="false" />
@ -173,3 +177,4 @@
- MQ 유형 및 연결 정보
- 연결에 필요한 호스트, 포트, 인증 정보
- LoadBalancer Service External IP (해당하는 경우)

17
common/src/main/java/com/kt/event/common/exception/ErrorCode.java
View File

@ -18,6 +18,10 @@ public enum ErrorCode {
COMMON_004("COMMON_004", "서버 내부 오류가 발생했습니다"),
COMMON_005("COMMON_005", "지원하지 않는 작업입니다"),
// 일반 에러 상수 (Legacy 호환용)
NOT_FOUND("NOT_FOUND", "요청한 리소스를 찾을 수 없습니다"),
INVALID_INPUT_VALUE("INVALID_INPUT_VALUE", "유효하지 않은 입력값입니다"),
// 인증/인가 에러 (AUTH_XXX)
AUTH_001("AUTH_001", "인증에 실패했습니다"),
AUTH_002("AUTH_002", "유효하지 않은 토큰입니다"),
@ -64,11 +68,14 @@ public enum ErrorCode {
DIST_004("DIST_004", "배포 상태를 찾을 수 없습니다"),
// 참여 에러 (PART_XXX)
PART_001("PART_001", "이미 참여한 이벤트입니다"),
PART_002("PART_002", "이벤트 참여 기간이 아닙니다"),
PART_003("PART_003", "참여자를 찾을 수 없습니다"),
PART_004("PART_004", "당첨자 추첨에 실패했습니다"),
PART_005("PART_005", "이벤트가 종료되었습니다"),
DUPLICATE_PARTICIPATION("PART_001", "이미 참여한 이벤트입니다"),
EVENT_NOT_ACTIVE("PART_002", "이벤트 참여 기간이 아닙니다"),
PARTICIPANT_NOT_FOUND("PART_003", "참여자를 찾을 수 없습니다"),
DRAW_FAILED("PART_004", "당첨자 추첨에 실패했습니다"),
EVENT_ENDED("PART_005", "이벤트가 종료되었습니다"),
ALREADY_DRAWN("PART_006", "이미 당첨자 추첨이 완료되었습니다"),
INSUFFICIENT_PARTICIPANTS("PART_007", "참여자 수가 당첨자 수보다 적습니다"),
NO_WINNERS_YET("PART_008", "아직 당첨자 추첨이 진행되지 않았습니다"),
// 분석 에러 (ANALYTICS_XXX)
ANALYTICS_001("ANALYTICS_001", "분석 데이터를 찾을 수 없습니다"),

62
common/src/main/java/com/kt/event/common/exception/GlobalExceptionHandler.java
View File

@ -2,6 +2,8 @@ package com.kt.event.common.exception;
import com.kt.event.common.dto.ErrorResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.data.mapping.PropertyReferenceException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.AccessDeniedException;
@ -161,6 +163,66 @@ public class GlobalExceptionHandler {
.body(errorResponse);
}
/**
* 데이터 무결성 제약 위반 예외 처리
*
* @param ex 데이터 무결성 예외
* @return 에러 응답
*/
@ExceptionHandler(DataIntegrityViolationException.class)
public ResponseEntity<ErrorResponse> handleDataIntegrityViolationException(DataIntegrityViolationException ex) {
log.warn("Data integrity violation: {}", ex.getMessage());
String message = "데이터 중복 또는 무결성 제약 위반이 발생했습니다";
String details = ex.getMessage();
// 중복 키 에러인 경우 메시지 개선
if (ex.getMessage() != null) {
if (ex.getMessage().contains("uk_event_phone") || ex.getMessage().contains("phone_number")) {
message = "이미 참여하신 이벤트입니다";
details = "동일한 전화번호로 이미 참여 기록이 있습니다";
} else if (ex.getMessage().contains("participant_id")) {
message = "참여 처리 중 오류가 발생했습니다";
details = "잠시 후 다시 시도해주세요";
}
}
ErrorResponse errorResponse = ErrorResponse.of(
ErrorCode.DUPLICATE_PARTICIPATION.getCode(),
message,
details
);
return ResponseEntity
.status(HttpStatus.CONFLICT)
.body(errorResponse);
}
/**
* 잘못된 정렬 필드 예외 처리
*
* @param ex 속성 참조 예외
* @return 에러 응답
*/
@ExceptionHandler(PropertyReferenceException.class)
public ResponseEntity<ErrorResponse> handlePropertyReferenceException(PropertyReferenceException ex) {
log.warn("Invalid sort property: {}", ex.getMessage());
String message = "잘못된 정렬 필드입니다";
String details = String.format("'%s' 필드는 존재하지 않습니다. 사용 가능한 필드: id, participantId, eventId, name, phoneNumber, email, storeVisited, bonusEntries, agreeMarketing, agreePrivacy, isWinner, winnerRank, wonAt, createdAt, updatedAt",
ex.getPropertyName());
ErrorResponse errorResponse = ErrorResponse.of(
ErrorCode.COMMON_003.getCode(),
message,
details
);
return ResponseEntity
.status(HttpStatus.BAD_REQUEST)
.body(errorResponse);
}
/**
* 일반 예외 처리
*

16
common/src/main/java/com/kt/event/common/security/JwtTokenProvider.java
View File

@ -12,6 +12,7 @@ import javax.crypto.SecretKey;
import java.nio.charset.StandardCharsets;
import java.util.Date;
import java.util.List;
import java.util.UUID;
/**
* JWT 토큰 생성 및 검증 제공자
@ -49,17 +50,19 @@ public class JwtTokenProvider {
* Access Token 생성
*
* @param userId 사용자 ID
* @param storeId 매장 ID
* @param email 이메일
* @param name 이름
* @param roles 역할 목록
* @return Access Token
*/
public String createAccessToken(Long userId, String email, String name, List<String> roles) {
public String createAccessToken(UUID userId, UUID storeId, String email, String name, List<String> roles) {
Date now = new Date();
Date expiryDate = new Date(now.getTime() + accessTokenValidityMs);
return Jwts.builder()
.subject(userId.toString())
.claim("storeId", storeId.toString())
.claim("email", email)
.claim("name", name)
.claim("roles", roles)
@ -76,7 +79,7 @@ public class JwtTokenProvider {
* @param userId 사용자 ID
* @return Refresh Token
*/
public String createRefreshToken(Long userId) {
public String createRefreshToken(UUID userId) {
Date now = new Date();
Date expiryDate = new Date(now.getTime() + refreshTokenValidityMs);
@ -95,9 +98,9 @@ public class JwtTokenProvider {
* @param token JWT 토큰
* @return 사용자 ID
*/
public Long getUserIdFromToken(String token) {
public UUID getUserIdFromToken(String token) {
Claims claims = parseToken(token);
return Long.parseLong(claims.getSubject());
return UUID.fromString(claims.getSubject());
}
/**
@ -109,13 +112,14 @@ public class JwtTokenProvider {
public UserPrincipal getUserPrincipalFromToken(String token) {
Claims claims = parseToken(token);
Long userId = Long.parseLong(claims.getSubject());
UUID userId = UUID.fromString(claims.getSubject());
UUID storeId = UUID.fromString(claims.get("storeId", String.class));
String email = claims.get("email", String.class);
String name = claims.get("name", String.class);
@SuppressWarnings("unchecked")
List<String> roles = claims.get("roles", List.class);
return new UserPrincipal(userId, email, name, roles);
return new UserPrincipal(userId, storeId, email, name, roles);
}
/**

10
common/src/main/java/com/kt/event/common/security/UserPrincipal.java
View File

@ -1,6 +1,7 @@
package com.kt.event.common.security;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
@ -8,6 +9,7 @@ import org.springframework.security.core.userdetails.UserDetails;
import java.util.Collection;
import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;
/**
@ -15,13 +17,19 @@ import java.util.stream.Collectors;
* JWT 토큰에서 추출한 사용자 정보를 담는 객체
*/
@Getter
@Builder
@AllArgsConstructor
public class UserPrincipal implements UserDetails {
/**
* 사용자 ID
*/
private final Long userId;
private final UUID userId;
/**
* 매장 ID
*/
private final UUID storeId;
/**
* 사용자 이메일

9
content-service/build.gradle
View File

@ -1,7 +1,10 @@
dependencies {
// Kafka Consumer
implementation 'org.springframework.kafka:spring-kafka'
configurations {
// Exclude JPA and PostgreSQL from inherited dependencies (Phase 3: Redis migration)
implementation.exclude group: 'org.springframework.boot', module: 'spring-boot-starter-data-jpa'
implementation.exclude group: 'org.postgresql', module: 'postgresql'
}
dependencies {
// Redis for AI data reading and image URL caching
implementation 'org.springframework.boot:spring-boot-starter-data-redis'

99
content-service/src/main/java/com/kt/event/content/biz/domain/Content.java Normal file
View File

@ -0,0 +1,99 @@
package com.kt.event.content.biz.domain;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
/**
* 콘텐츠 도메인 모델
* 이벤트에 대한 전체 콘텐츠 정보 (이미지 목록 포함)
*/
@Getter
@Builder
@AllArgsConstructor
public class Content {
/**
* 콘텐츠 ID
*/
private final Long id;
/**
* 이벤트 ID (이벤트 초안 ID)
*/
private final Long eventDraftId;
/**
* 이벤트 제목
*/
private final String eventTitle;
/**
* 이벤트 설명
*/
private final String eventDescription;
/**
* 생성된 이미지 목록
*/
@Builder.Default
private final List<GeneratedImage> images = new ArrayList<>();
/**
* 생성일시
*/
private final LocalDateTime createdAt;
/**
* 수정일시
*/
private final LocalDateTime updatedAt;
/**
* 이미지 추가
*
* @param image 생성된 이미지
*/
public void addImage(GeneratedImage image) {
this.images.add(image);
}
/**
* 선택된 이미지 조회
*
* @return 선택된 이미지 목록
*/
public List<GeneratedImage> getSelectedImages() {
return images.stream()
.filter(GeneratedImage::isSelected)
.toList();
}
/**
* 특정 스타일의 이미지 조회
*
* @param style 이미지 스타일
* @return 해당 스타일의 이미지 목록
*/
public List<GeneratedImage> getImagesByStyle(ImageStyle style) {
return images.stream()
.filter(image -> image.getStyle() == style)
.toList();
}
/**
* 특정 플랫폼의 이미지 조회
*
* @param platform 플랫폼
* @return 해당 플랫폼의 이미지 목록
*/
public List<GeneratedImage> getImagesByPlatform(Platform platform) {
return images.stream()
.filter(image -> image.getPlatform() == platform)
.toList();
}
}

76
content-service/src/main/java/com/kt/event/content/biz/domain/GeneratedImage.java Normal file
View File

@ -0,0 +1,76 @@
package com.kt.event.content.biz.domain;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import java.time.LocalDateTime;
/**
* 생성된 이미지 도메인 모델
* AI가 생성한 이미지의 비즈니스 정보
*/
@Getter
@Builder
@AllArgsConstructor
public class GeneratedImage {
/**
* 이미지 ID
*/
private final Long id;
/**
* 이벤트 ID (이벤트 초안 ID)
*/
private final Long eventDraftId;
/**
* 이미지 스타일
*/
private final ImageStyle style;
/**
* 플랫폼
*/
private final Platform platform;
/**
* CDN URL (Azure Blob Storage)
*/
private final String cdnUrl;
/**
* 프롬프트
*/
private final String prompt;
/**
* 선택 여부
*/
private boolean selected;
/**
* 생성일시
*/
private LocalDateTime createdAt;
/**
* 수정일시
*/
private LocalDateTime updatedAt;
/**
* 이미지 선택
*/
public void select() {
this.selected = true;
}
/**
* 이미지 선택 해제
*/
public void deselect() {
this.selected = false;
}
}

32
content-service/src/main/java/com/kt/event/content/biz/domain/ImageStyle.java Normal file
View File

@ -0,0 +1,32 @@
package com.kt.event.content.biz.domain;
/**
* 이미지 스타일 enum
* AI가 생성하는 이미지의 스타일 유형
*/
public enum ImageStyle {
/**
* 심플 스타일 - 깔끔하고 미니멀한 디자인
*/
SIMPLE("심플"),
/**
* 화려한 스타일 - 화려하고 풍부한 디자인
*/
FANCY("화려한"),
/**
* 트렌디 스타일 - 최신 트렌드를 반영한 디자인
*/
TRENDY("트렌디");
private final String displayName;
ImageStyle(String displayName) {
this.displayName = displayName;
}
public String getDisplayName() {
return displayName;
}
}

140
content-service/src/main/java/com/kt/event/content/biz/domain/Job.java Normal file
View File

@ -0,0 +1,140 @@
package com.kt.event.content.biz.domain;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import java.time.LocalDateTime;
/**
* Job 도메인 모델
* 이미지 생성 작업의 비즈니스 정보
*/
@Getter
@Builder
@AllArgsConstructor
public class Job {
/**
* Job 상태 enum
*/
public enum Status {
PENDING, // 대기 중
PROCESSING, // 처리 중
COMPLETED, // 완료
FAILED // 실패
}
/**
* Job ID
*/
private final String id;
/**
* 이벤트 ID (이벤트 초안 ID)
*/
private final Long eventDraftId;
/**
* Job 타입 (image-generation)
*/
private final String jobType;
/**
* Job 상태
*/
private Status status;
/**
* 진행률 (0-100)
*/
private int progress;
/**
* 결과 메시지
*/
private String resultMessage;
/**
* 에러 메시지
*/
private String errorMessage;
/**
* 생성일시
*/
private final LocalDateTime createdAt;
/**
* 수정일시
*/
private final LocalDateTime updatedAt;
/**
* Job 시작
*/
public void start() {
this.status = Status.PROCESSING;
this.progress = 0;
}
/**
* 진행률 업데이트
*
* @param progress 진행률 (0-100)
*/
public void updateProgress(int progress) {
if (progress < 0 || progress > 100) {
throw new IllegalArgumentException("진행률은 0-100 사이여야 합니다");
}
this.progress = progress;
}
/**
* Job 완료 처리
*
* @param resultMessage 결과 메시지
*/
public void complete(String resultMessage) {
this.status = Status.COMPLETED;
this.progress = 100;
this.resultMessage = resultMessage;
}
/**
* Job 실패 처리
*
* @param errorMessage 에러 메시지
*/
public void fail(String errorMessage) {
this.status = Status.FAILED;
this.errorMessage = errorMessage;
}
/**
* Job 진행 중 여부
*
* @return 진행 중이면 true
*/
public boolean isProcessing() {
return status == Status.PROCESSING;
}
/**
* Job 완료 여부
*
* @return 완료되었으면 true
*/
public boolean isCompleted() {
return status == Status.COMPLETED;
}
/**
* Job 실패 여부
*
* @return 실패했으면 true
*/
public boolean isFailed() {
return status == Status.FAILED;
}
}

53
content-service/src/main/java/com/kt/event/content/biz/domain/Platform.java Normal file
View File

@ -0,0 +1,53 @@
package com.kt.event.content.biz.domain;
/**
* 플랫폼 enum
* 이미지가 배포될 SNS 플랫폼 유형
*/
public enum Platform {
/**
* Instagram - 1080x1080 정사각형
*/
INSTAGRAM("Instagram", 1080, 1080),
/**
* 네이버 블로그 - 800x600
*/
NAVER("네이버 블로그", 800, 600),
/**
* 카카오 채널 - 800x800 정사각형
*/
KAKAO("카카오 채널", 800, 800);
private final String displayName;
private final int width;
private final int height;
Platform(String displayName, int width, int height) {
this.displayName = displayName;
this.width = width;
this.height = height;
}
public String getDisplayName() {
return displayName;
}
public int getWidth() {
return width;
}
public int getHeight() {
return height;
}
/**
* 이미지 크기 문자열 반환
*
* @return 가로x세로 형식 (예: 1080x1080)
*/
public String getSizeString() {
return width + "x" + height;
}
}

40
content-service/src/main/java/com/kt/event/content/biz/dto/ContentCommand.java Normal file
View File

@ -0,0 +1,40 @@
package com.kt.event.content.biz.dto;
import com.kt.event.content.biz.domain.ImageStyle;
import com.kt.event.content.biz.domain.Platform;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import java.util.List;
/**
* 콘텐츠 관련 커맨드 DTO
*/
public class ContentCommand {
/**
* 이미지 생성 요청 커맨드
*/
@Getter
@Builder
@AllArgsConstructor
public static class GenerateImages {
private Long eventDraftId;
private String eventTitle;
private String eventDescription;
private List<ImageStyle> styles;
private List<Platform> platforms;
}
/**
* 이미지 재생성 요청 커맨드
*/
@Getter
@Builder
@AllArgsConstructor
public static class RegenerateImage {
private Long imageId;
private String newPrompt;
}
}

47
content-service/src/main/java/com/kt/event/content/biz/dto/ContentInfo.java Normal file
View File

@ -0,0 +1,47 @@
package com.kt.event.content.biz.dto;
import com.kt.event.content.biz.domain.Content;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import java.time.LocalDateTime;
import java.util.List;
import java.util.stream.Collectors;
/**
* 콘텐츠 정보 DTO
*/
@Getter
@Builder
@AllArgsConstructor
public class ContentInfo {
private Long id;
private Long eventDraftId;
private String eventTitle;
private String eventDescription;
private List<ImageInfo> images;
private LocalDateTime createdAt;
private LocalDateTime updatedAt;
/**
* 도메인 모델로부터 생성
*
* @param content 콘텐츠 도메인 모델
* @return ContentInfo
*/
public static ContentInfo from(Content content) {
return ContentInfo.builder()
.id(content.getId())
.eventDraftId(content.getEventDraftId())
.eventTitle(content.getEventTitle())
.eventDescription(content.getEventDescription())
.images(content.getImages().stream()
.map(ImageInfo::from)
.collect(Collectors.toList()))
.createdAt(content.getCreatedAt())
.updatedAt(content.getUpdatedAt())
.build();
}
}

49
content-service/src/main/java/com/kt/event/content/biz/dto/ImageInfo.java Normal file
View File

@ -0,0 +1,49 @@
package com.kt.event.content.biz.dto;
import com.kt.event.content.biz.domain.GeneratedImage;
import com.kt.event.content.biz.domain.ImageStyle;
import com.kt.event.content.biz.domain.Platform;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import java.time.LocalDateTime;
/**
* 이미지 정보 DTO
*/
@Getter
@Builder
@AllArgsConstructor
public class ImageInfo {
private Long id;
private Long eventDraftId;
private ImageStyle style;
private Platform platform;
private String cdnUrl;
private String prompt;
private boolean selected;
private LocalDateTime createdAt;
private LocalDateTime updatedAt;
/**
* 도메인 모델로부터 생성
*
* @param image 이미지 도메인 모델
* @return ImageInfo
*/
public static ImageInfo from(GeneratedImage image) {
return ImageInfo.builder()
.id(image.getId())
.eventDraftId(image.getEventDraftId())
.style(image.getStyle())
.platform(image.getPlatform())
.cdnUrl(image.getCdnUrl())
.prompt(image.getPrompt())
.selected(image.isSelected())
.createdAt(image.getCreatedAt())
.updatedAt(image.getUpdatedAt())
.build();
}
}

47
content-service/src/main/java/com/kt/event/content/biz/dto/JobInfo.java Normal file
View File

@ -0,0 +1,47 @@
package com.kt.event.content.biz.dto;
import com.kt.event.content.biz.domain.Job;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import java.time.LocalDateTime;
/**
* Job 정보 DTO
*/
@Getter
@Builder
@AllArgsConstructor
public class JobInfo {
private String id;
private Long eventDraftId;
private String jobType;
private Job.Status status;
private int progress;
private String resultMessage;
private String errorMessage;
private LocalDateTime createdAt;
private LocalDateTime updatedAt;
/**
* 도메인 모델로부터 생성
*
* @param job Job 도메인 모델
* @return JobInfo
*/
public static JobInfo from(Job job) {
return JobInfo.builder()
.id(job.getId())
.eventDraftId(job.getEventDraftId())
.jobType(job.getJobType())
.status(job.getStatus())
.progress(job.getProgress())
.resultMessage(job.getResultMessage())
.errorMessage(job.getErrorMessage())
.createdAt(job.getCreatedAt())
.updatedAt(job.getUpdatedAt())
.build();
}
}

56
content-service/src/main/java/com/kt/event/content/biz/dto/RedisAIEventData.java Normal file
View File

@ -0,0 +1,56 @@
package com.kt.event.content.biz.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Map;
/**
* AI Service가 Redis에 저장한 이벤트 데이터 (읽기 전용)
*
* Key Pattern: ai:event:{eventDraftId}
* Data Type: Hash
* TTL: 24시간 (86400초)
*
* 예시:
* - ai:event:1
*
* Note: 이 데이터는 AI Service가 생성하고 Content Service는 읽기만 합니다.
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class RedisAIEventData {
/**
* 이벤트 초안 ID
*/
private Long eventDraftId;
/**
* 이벤트 제목
*/
private String eventTitle;
/**
* 이벤트 설명
*/
private String eventDescription;
/**
* 타겟 고객
*/
private String targetAudience;
/**
* 이벤트 목적
*/
private String eventObjective;
/**
* AI가 생성한 추가 데이터
*/
private Map<String, Object> additionalData;
}

72
content-service/src/main/java/com/kt/event/content/biz/dto/RedisImageData.java Normal file
View File

@ -0,0 +1,72 @@
package com.kt.event.content.biz.dto;
import com.kt.event.content.biz.domain.ImageStyle;
import com.kt.event.content.biz.domain.Platform;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
/**
* Redis에 저장되는 이미지 데이터 구조
*
* Key Pattern: content:image:{eventDraftId}:{style}:{platform}
* Data Type: String (JSON)
* TTL: 7일 (604800초)
*
* 예시:
* - content:image:1:FANCY:INSTAGRAM
* - content:image:1:SIMPLE:KAKAO
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class RedisImageData {
/**
* 이미지 고유 ID
*/
private Long id;
/**
* 이벤트 초안 ID
*/
private Long eventDraftId;
/**
* 이미지 스타일 (FANCY, SIMPLE, TRENDY)
*/
private ImageStyle style;
/**
* 플랫폼 (INSTAGRAM, KAKAO, NAVER)
*/
private Platform platform;
/**
* CDN 이미지 URL
*/
private String cdnUrl;
/**
* 이미지 생성 프롬프트
*/
private String prompt;
/**
* 선택 여부
*/
private Boolean selected;
/**
* 생성 일시
*/
private LocalDateTime createdAt;
/**
* 수정 일시
*/
private LocalDateTime updatedAt;
}

70
content-service/src/main/java/com/kt/event/content/biz/dto/RedisJobData.java Normal file
View File

@ -0,0 +1,70 @@
package com.kt.event.content.biz.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
/**
* Redis에 저장되는 Job 상태 정보
*
* Key Pattern: job:{jobId}
* Data Type: Hash
* TTL: 1시간 (3600초)
*
* 예시:
* - job:job-mock-7ada8bd3
* - job:job-regen-df2bb3a3
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class RedisJobData {
/**
* Job ID (예: job-mock-7ada8bd3)
*/
private String id;
/**
* 이벤트 초안 ID
*/
private Long eventDraftId;
/**
* Job 타입 (image-generation, image-regeneration)
*/
private String jobType;
/**
* 상태 (PENDING, IN_PROGRESS, COMPLETED, FAILED)
*/
private String status;
/**
* 진행률 (0-100)
*/
private Integer progress;
/**
* 결과 메시지
*/
private String resultMessage;
/**
* 에러 메시지
*/
private String errorMessage;
/**
* 생성 일시
*/
private LocalDateTime createdAt;
/**
* 수정 일시
*/
private LocalDateTime updatedAt;
}

38
content-service/src/main/java/com/kt/event/content/biz/service/DeleteImageService.java Normal file
View File

@ -0,0 +1,38 @@
package com.kt.event.content.biz.service;
import com.kt.event.common.exception.BusinessException;
import com.kt.event.common.exception.ErrorCode;
import com.kt.event.content.biz.usecase.in.DeleteImageUseCase;
import com.kt.event.content.biz.usecase.out.ContentReader;
import com.kt.event.content.biz.usecase.out.ContentWriter;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* 이미지 삭제 서비스
*/
@Slf4j
@Service
@RequiredArgsConstructor
@Transactional
public class DeleteImageService implements DeleteImageUseCase {
private final ContentReader contentReader;
private final ContentWriter contentWriter;
@Override
public void execute(Long imageId) {
log.info("[DeleteImageService] 이미지 삭제 요청: imageId={}", imageId);
// 이미지 존재 확인
contentReader.findImageById(imageId)
.orElseThrow(() -> new BusinessException(ErrorCode.COMMON_001, "이미지를 찾을 수 없습니다"));
// 이미지 삭제
contentWriter.deleteImageById(imageId);
log.info("[DeleteImageService] 이미지 삭제 완료: imageId={}", imageId);
}
}

32
content-service/src/main/java/com/kt/event/content/biz/service/GetEventContentService.java Normal file
View File

@ -0,0 +1,32 @@
package com.kt.event.content.biz.service;
import com.kt.event.common.exception.BusinessException;
import com.kt.event.common.exception.ErrorCode;
import com.kt.event.content.biz.domain.Content;
import com.kt.event.content.biz.dto.ContentInfo;
import com.kt.event.content.biz.usecase.in.GetEventContentUseCase;
import com.kt.event.content.biz.usecase.out.ContentReader;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* 이벤트 콘텐츠 조회 서비스
*/
@Slf4j
@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class GetEventContentService implements GetEventContentUseCase {
private final ContentReader contentReader;
@Override
public ContentInfo execute(Long eventDraftId) {
Content content = contentReader.findByEventDraftIdWithImages(eventDraftId)
.orElseThrow(() -> new BusinessException(ErrorCode.COMMON_001, "콘텐츠를 찾을 수 없습니다"));
return ContentInfo.from(content);
}
}

32
content-service/src/main/java/com/kt/event/content/biz/service/GetImageDetailService.java Normal file
View File

@ -0,0 +1,32 @@
package com.kt.event.content.biz.service;
import com.kt.event.common.exception.BusinessException;
import com.kt.event.common.exception.ErrorCode;
import com.kt.event.content.biz.domain.GeneratedImage;
import com.kt.event.content.biz.dto.ImageInfo;
import com.kt.event.content.biz.usecase.in.GetImageDetailUseCase;
import com.kt.event.content.biz.usecase.out.ContentReader;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* 이미지 상세 조회 서비스
*/
@Slf4j
@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class GetImageDetailService implements GetImageDetailUseCase {
private final ContentReader contentReader;
@Override
public ImageInfo execute(Long imageId) {
GeneratedImage image = contentReader.findImageById(imageId)
.orElseThrow(() -> new BusinessException(ErrorCode.COMMON_001, "이미지를 찾을 수 없습니다"));
return ImageInfo.from(image);
}
}

41
content-service/src/main/java/com/kt/event/content/biz/service/GetImageListService.java Normal file
View File

@ -0,0 +1,41 @@
package com.kt.event.content.biz.service;
import com.kt.event.content.biz.domain.GeneratedImage;
import com.kt.event.content.biz.domain.ImageStyle;
import com.kt.event.content.biz.domain.Platform;
import com.kt.event.content.biz.dto.ImageInfo;
import com.kt.event.content.biz.usecase.in.GetImageListUseCase;
import com.kt.event.content.biz.usecase.out.ContentReader;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.stream.Collectors;
/**
* 이미지 목록 조회 서비스
*/
@Slf4j
@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class GetImageListService implements GetImageListUseCase {
private final ContentReader contentReader;
@Override
public List<ImageInfo> execute(Long eventDraftId, ImageStyle style, Platform platform) {
log.info("이미지 목록 조회: eventDraftId={}, style={}, platform={}", eventDraftId, style, platform);
List<GeneratedImage> images = contentReader.findImagesByEventDraftId(eventDraftId);
// 필터링 적용
return images.stream()
.filter(image -> style == null || image.getStyle() == style)
.filter(image -> platform == null || image.getPlatform() == platform)
.map(ImageInfo::from)
.collect(Collectors.toList());
}
}

47
content-service/src/main/java/com/kt/event/content/biz/service/JobManagementService.java Normal file
View File

@ -0,0 +1,47 @@
package com.kt.event.content.biz.service;
import com.kt.event.common.exception.BusinessException;
import com.kt.event.common.exception.ErrorCode;
import com.kt.event.content.biz.domain.Job;
import com.kt.event.content.biz.dto.JobInfo;
import com.kt.event.content.biz.dto.RedisJobData;
import com.kt.event.content.biz.usecase.in.GetJobStatusUseCase;
import com.kt.event.content.biz.usecase.out.JobReader;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* Job 관리 서비스
* Job 상태 조회 기능 제공
*/
@Slf4j
@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class JobManagementService implements GetJobStatusUseCase {
private final JobReader jobReader;
@Override
public JobInfo execute(String jobId) {
RedisJobData jobData = jobReader.getJob(jobId)
.orElseThrow(() -> new BusinessException(ErrorCode.COMMON_001, "Job을 찾을 수 없습니다"));
// RedisJobData를 Job 도메인 객체로 변환
Job job = Job.builder()
.id(jobData.getId())
.eventDraftId(jobData.getEventDraftId())
.jobType(jobData.getJobType())
.status(Job.Status.valueOf(jobData.getStatus()))
.progress(jobData.getProgress())
.resultMessage(jobData.getResultMessage())
.errorMessage(jobData.getErrorMessage())
.createdAt(jobData.getCreatedAt())
.updatedAt(jobData.getUpdatedAt())
.build();
return JobInfo.from(job);
}
}

154
content-service/src/main/java/com/kt/event/content/biz/service/mock/MockGenerateImagesService.java Normal file
View File

@ -0,0 +1,154 @@
package com.kt.event.content.biz.service.mock;
import com.kt.event.content.biz.domain.Content;
import com.kt.event.content.biz.domain.GeneratedImage;
import com.kt.event.content.biz.domain.ImageStyle;
import com.kt.event.content.biz.domain.Job;
import com.kt.event.content.biz.domain.Platform;
import com.kt.event.content.biz.dto.ContentCommand;
import com.kt.event.content.biz.dto.JobInfo;
import com.kt.event.content.biz.dto.RedisJobData;
import com.kt.event.content.biz.usecase.in.GenerateImagesUseCase;
import com.kt.event.content.biz.usecase.out.ContentWriter;
import com.kt.event.content.biz.usecase.out.JobWriter;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Profile;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
/**
* Mock 이미지 생성 서비스 (테스트용)
* 실제 Kafka 연동 전까지 사용
*
* 테스트를 위해 실제로 Content와 GeneratedImage를 생성합니다.
*/
@Slf4j
@Service
@Profile({"local", "test", "dev"})
@RequiredArgsConstructor
public class MockGenerateImagesService implements GenerateImagesUseCase {
private final JobWriter jobWriter;
private final ContentWriter contentWriter;
@Override
public JobInfo execute(ContentCommand.GenerateImages command) {
log.info("[MOCK] 이미지 생성 요청: eventDraftId={}, styles={}, platforms={}",
command.getEventDraftId(), command.getStyles(), command.getPlatforms());
// Mock Job 생성
String jobId = "job-mock-" + UUID.randomUUID().toString().substring(0, 8);
Job job = Job.builder()
.id(jobId)
.eventDraftId(command.getEventDraftId())
.jobType("image-generation")
.status(Job.Status.PENDING)
.progress(0)
.createdAt(java.time.LocalDateTime.now())
.updatedAt(java.time.LocalDateTime.now())
.build();
// Job 저장 (Job 도메인을 RedisJobData로 변환)
RedisJobData jobData = RedisJobData.builder()
.id(job.getId())
.eventDraftId(job.getEventDraftId())
.jobType(job.getJobType())
.status(job.getStatus().name())
.progress(job.getProgress())
.createdAt(job.getCreatedAt())
.updatedAt(job.getUpdatedAt())
.build();
jobWriter.saveJob(jobData, 3600); // TTL 1시간
log.info("[MOCK] Job 생성 완료: jobId={}", jobId);
// 비동기로 이미지 생성 시뮬레이션
processImageGeneration(jobId, command);
return JobInfo.from(job);
}
@Async
private void processImageGeneration(String jobId, ContentCommand.GenerateImages command) {
try {
log.info("[MOCK] 이미지 생성 시작: jobId={}", jobId);
// 1초 대기 (이미지 생성 시뮬레이션)
Thread.sleep(1000);
// Content 생성 또는 조회
Content content = Content.builder()
.eventDraftId(command.getEventDraftId())
.eventTitle("Mock 이벤트 제목 " + command.getEventDraftId())
.eventDescription("Mock 이벤트 설명입니다. 테스트를 위한 Mock 데이터입니다.")
.createdAt(java.time.LocalDateTime.now())
.updatedAt(java.time.LocalDateTime.now())
.build();
Content savedContent = contentWriter.save(content);
log.info("[MOCK] Content 생성 완료: contentId={}", savedContent.getId());
// 스타일 x 플랫폼 조합으로 이미지 생성
List<ImageStyle> styles = command.getStyles() != null && !command.getStyles().isEmpty()
? command.getStyles()
: List.of(ImageStyle.FANCY, ImageStyle.SIMPLE);
List<Platform> platforms = command.getPlatforms() != null && !command.getPlatforms().isEmpty()
? command.getPlatforms()
: List.of(Platform.INSTAGRAM, Platform.KAKAO);
List<GeneratedImage> images = new ArrayList<>();
int count = 0;
for (ImageStyle style : styles) {
for (Platform platform : platforms) {
count++;
String mockCdnUrl = String.format(
"https://mock-cdn.azure.com/images/%d/%s_%s_%s.png",
command.getEventDraftId(),
style.name().toLowerCase(),
platform.name().toLowerCase(),
UUID.randomUUID().toString().substring(0, 8)
);
GeneratedImage image = GeneratedImage.builder()
.eventDraftId(command.getEventDraftId())
.style(style)
.platform(platform)
.cdnUrl(mockCdnUrl)
.prompt(String.format("Mock prompt for %s style on %s platform", style, platform))
.selected(false)
.createdAt(java.time.LocalDateTime.now())
.updatedAt(java.time.LocalDateTime.now())
.build();
// 첫 번째 이미지를 선택된 이미지로 설정
if (count == 1) {
image.select();
}
GeneratedImage savedImage = contentWriter.saveImage(image);
images.add(savedImage);
log.info("[MOCK] 이미지 생성: imageId={}, style={}, platform={}",
savedImage.getId(), style, platform);
}
}
// Job 상태 업데이트: COMPLETED
String resultMessage = String.format("%d개의 이미지가 성공적으로 생성되었습니다.", images.size());
jobWriter.updateJobStatus(jobId, "COMPLETED", 100);
jobWriter.updateJobResult(jobId, resultMessage);
log.info("[MOCK] Job 완료: jobId={}, 생성된 이미지 수={}", jobId, images.size());
} catch (Exception e) {
log.error("[MOCK] 이미지 생성 실패: jobId={}", jobId, e);
// Job 상태 업데이트: FAILED
jobWriter.updateJobError(jobId, e.getMessage());
}
}
}

62
content-service/src/main/java/com/kt/event/content/biz/service/mock/MockRegenerateImageService.java Normal file
View File

@ -0,0 +1,62 @@
package com.kt.event.content.biz.service.mock;
import com.kt.event.content.biz.domain.Job;
import com.kt.event.content.biz.dto.ContentCommand;
import com.kt.event.content.biz.dto.JobInfo;
import com.kt.event.content.biz.dto.RedisJobData;
import com.kt.event.content.biz.usecase.in.RegenerateImageUseCase;
import com.kt.event.content.biz.usecase.out.JobWriter;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Service;
import java.util.UUID;
/**
* Mock 이미지 재생성 서비스 (테스트용)
* 실제 구현 전까지 사용
*/
@Slf4j
@Service
@Profile({"local", "test", "dev"})
@RequiredArgsConstructor
public class MockRegenerateImageService implements RegenerateImageUseCase {
private final JobWriter jobWriter;
@Override
public JobInfo execute(ContentCommand.RegenerateImage command) {
log.info("[MOCK] 이미지 재생성 요청: imageId={}", command.getImageId());
// Mock Job 생성
String jobId = "job-regen-" + UUID.randomUUID().toString().substring(0, 8);
Job job = Job.builder()
.id(jobId)
.eventDraftId(999L) // Mock event ID
.jobType("image-regeneration")
.status(Job.Status.PENDING)
.progress(0)
.createdAt(java.time.LocalDateTime.now())
.updatedAt(java.time.LocalDateTime.now())
.build();
// Job 저장 (Job 도메인을 RedisJobData로 변환)
RedisJobData jobData = RedisJobData.builder()
.id(job.getId())
.eventDraftId(job.getEventDraftId())
.jobType(job.getJobType())
.status(job.getStatus().name())
.progress(job.getProgress())
.createdAt(job.getCreatedAt())
.updatedAt(job.getUpdatedAt())
.build();
jobWriter.saveJob(jobData, 3600); // TTL 1시간
log.info("[MOCK] 재생성 Job 생성 완료: jobId={}", jobId);
return JobInfo.from(job);
}
}

14
content-service/src/main/java/com/kt/event/content/biz/usecase/in/DeleteImageUseCase.java Normal file
View File

@ -0,0 +1,14 @@
package com.kt.event.content.biz.usecase.in;
/**
* 이미지 삭제 UseCase
*/
public interface DeleteImageUseCase {
/**
* 이미지 삭제
*
* @param imageId 삭제할 이미지 ID
*/
void execute(Long imageId);
}

19
content-service/src/main/java/com/kt/event/content/biz/usecase/in/GenerateImagesUseCase.java Normal file
View File

@ -0,0 +1,19 @@
package com.kt.event.content.biz.usecase.in;
import com.kt.event.content.biz.dto.ContentCommand;
import com.kt.event.content.biz.dto.JobInfo;
/**
* 이미지 생성 UseCase
* 비동기로 이미지 생성 작업을 시작
*/
public interface GenerateImagesUseCase {
/**
* 이미지 생성 요청
*
* @param command 이미지 생성 커맨드
* @return Job 정보
*/
JobInfo execute(ContentCommand.GenerateImages command);
}

17
content-service/src/main/java/com/kt/event/content/biz/usecase/in/GetEventContentUseCase.java Normal file
View File

@ -0,0 +1,17 @@
package com.kt.event.content.biz.usecase.in;
import com.kt.event.content.biz.dto.ContentInfo;
/**
* 이벤트 콘텐츠 조회 UseCase
*/
public interface GetEventContentUseCase {
/**
* 이벤트 전체 콘텐츠 조회 (이미지 목록 포함)
*
* @param eventDraftId 이벤트 초안 ID
* @return 콘텐츠 정보
*/
ContentInfo execute(Long eventDraftId);
}

17
content-service/src/main/java/com/kt/event/content/biz/usecase/in/GetImageDetailUseCase.java Normal file
View File

@ -0,0 +1,17 @@
package com.kt.event.content.biz.usecase.in;
import com.kt.event.content.biz.dto.ImageInfo;
/**
* 이미지 상세 조회 UseCase
*/
public interface GetImageDetailUseCase {
/**
* 이미지 상세 정보 조회
*
* @param imageId 이미지 ID
* @return 이미지 정보
*/
ImageInfo execute(Long imageId);
}

23
content-service/src/main/java/com/kt/event/content/biz/usecase/in/GetImageListUseCase.java Normal file
View File

@ -0,0 +1,23 @@
package com.kt.event.content.biz.usecase.in;
import com.kt.event.content.biz.domain.ImageStyle;
import com.kt.event.content.biz.domain.Platform;
import com.kt.event.content.biz.dto.ImageInfo;
import java.util.List;
/**
* 이미지 목록 조회 UseCase
*/
public interface GetImageListUseCase {
/**
* 이벤트의 이미지 목록 조회 (필터링 지원)
*
* @param eventDraftId 이벤트 초안 ID
* @param style 이미지 스타일 필터 (null이면 전체)
* @param platform 플랫폼 필터 (null이면 전체)
* @return 이미지 정보 목록
*/
List<ImageInfo> execute(Long eventDraftId, ImageStyle style, Platform platform);
}

17
content-service/src/main/java/com/kt/event/content/biz/usecase/in/GetJobStatusUseCase.java Normal file
View File

@ -0,0 +1,17 @@
package com.kt.event.content.biz.usecase.in;
import com.kt.event.content.biz.dto.JobInfo;
/**
* Job 상태 조회 UseCase
*/
public interface GetJobStatusUseCase {
/**
* Job 상태 조회
*
* @param jobId Job ID
* @return Job 정보
*/
JobInfo execute(String jobId);
}

18
content-service/src/main/java/com/kt/event/content/biz/usecase/in/RegenerateImageUseCase.java Normal file
View File

@ -0,0 +1,18 @@
package com.kt.event.content.biz.usecase.in;
import com.kt.event.content.biz.dto.ContentCommand;
import com.kt.event.content.biz.dto.JobInfo;
/**
* 이미지 재생성 UseCase
*/
public interface RegenerateImageUseCase {
/**
* 이미지 재생성 요청
*
* @param command 이미지 재생성 커맨드
* @return Job 정보
*/
JobInfo execute(ContentCommand.RegenerateImage command);
}

17
content-service/src/main/java/com/kt/event/content/biz/usecase/out/CDNUploader.java Normal file
View File

@ -0,0 +1,17 @@
package com.kt.event.content.biz.usecase.out;
/**
* CDN 업로드 포트
* Azure Blob Storage에 이미지 업로드
*/
public interface CDNUploader {
/**
* 이미지 업로드
*
* @param imageData 이미지 바이트 데이터
* @param fileName 파일명
* @return CDN URL
*/
String upload(byte[] imageData, String fileName);
}

37
content-service/src/main/java/com/kt/event/content/biz/usecase/out/ContentReader.java Normal file
View File

@ -0,0 +1,37 @@
package com.kt.event.content.biz.usecase.out;
import com.kt.event.content.biz.domain.Content;
import com.kt.event.content.biz.domain.GeneratedImage;
import java.util.List;
import java.util.Optional;
/**
* 콘텐츠 조회 포트
*/
public interface ContentReader {
/**
* 이벤트 초안 ID로 콘텐츠 조회 (이미지 목록 포함)
*
* @param eventDraftId 이벤트 초안 ID
* @return 콘텐츠 도메인 모델
*/
Optional<Content> findByEventDraftIdWithImages(Long eventDraftId);
/**
* 이미지 ID로 이미지 조회
*
* @param imageId 이미지 ID
* @return 이미지 도메인 모델
*/
Optional<GeneratedImage> findImageById(Long imageId);
/**
* 이벤트 초안 ID로 이미지 목록 조회
*
* @param eventDraftId 이벤트 초안 ID
* @return 이미지 도메인 모델 목록
*/
List<GeneratedImage> findImagesByEventDraftId(Long eventDraftId);
}

33
content-service/src/main/java/com/kt/event/content/biz/usecase/out/ContentWriter.java Normal file
View File

@ -0,0 +1,33 @@
package com.kt.event.content.biz.usecase.out;
import com.kt.event.content.biz.domain.Content;
import com.kt.event.content.biz.domain.GeneratedImage;
/**
* 콘텐츠 저장 포트
*/
public interface ContentWriter {
/**
* 콘텐츠 저장
*
* @param content 콘텐츠 도메인 모델
* @return 저장된 콘텐츠
*/
Content save(Content content);
/**
* 이미지 저장
*
* @param image 이미지 도메인 모델
* @return 저장된 이미지
*/
GeneratedImage saveImage(GeneratedImage image);
/**
* 이미지 ID로 이미지 삭제
*
* @param imageId 이미지 ID
*/
void deleteImageById(Long imageId);
}

21
content-service/src/main/java/com/kt/event/content/biz/usecase/out/ImageGeneratorCaller.java Normal file
View File

@ -0,0 +1,21 @@
package com.kt.event.content.biz.usecase.out;
import com.kt.event.content.biz.domain.ImageStyle;
import com.kt.event.content.biz.domain.Platform;
/**
* 이미지 생성 API 호출 포트
* Stable Diffusion, DALL-E 등 외부 이미지 생성 API 호출
*/
public interface ImageGeneratorCaller {
/**
* 이미지 생성
*
* @param prompt 프롬프트
* @param style 이미지 스타일
* @param platform 플랫폼 (이미지 크기 결정)
* @return 생성된 이미지 바이트 데이터
*/
byte[] generateImage(String prompt, ImageStyle style, Platform platform);
}

32
content-service/src/main/java/com/kt/event/content/biz/usecase/out/ImageReader.java Normal file
View File

@ -0,0 +1,32 @@
package com.kt.event.content.biz.usecase.out;
import com.kt.event.content.biz.domain.ImageStyle;
import com.kt.event.content.biz.domain.Platform;
import com.kt.event.content.biz.dto.RedisImageData;
import java.util.List;
import java.util.Optional;
/**
* 이미지 조회 Port (Output Port)
*/
public interface ImageReader {
/**
* 특정 이미지 조회
*
* @param eventDraftId 이벤트 초안 ID
* @param style 이미지 스타일
* @param platform 플랫폼
* @return 이미지 데이터
*/
Optional<RedisImageData> getImage(Long eventDraftId, ImageStyle style, Platform platform);
/**
* 이벤트의 모든 이미지 조회
*
* @param eventDraftId 이벤트 초안 ID
* @return 이미지 목록
*/
List<RedisImageData> getImagesByEventId(Long eventDraftId);
}

39
content-service/src/main/java/com/kt/event/content/biz/usecase/out/ImageWriter.java Normal file
View File

@ -0,0 +1,39 @@
package com.kt.event.content.biz.usecase.out;
import com.kt.event.content.biz.domain.ImageStyle;
import com.kt.event.content.biz.domain.Platform;
import com.kt.event.content.biz.dto.RedisImageData;
import java.util.List;
/**
* 이미지 저장 Port (Output Port)
*/
public interface ImageWriter {
/**
* 단일 이미지 저장
*
* @param imageData 이미지 데이터
* @param ttlSeconds TTL (초 단위)
*/
void saveImage(RedisImageData imageData, long ttlSeconds);
/**
* 여러 이미지 저장
*
* @param eventDraftId 이벤트 초안 ID
* @param images 이미지 목록
* @param ttlSeconds TTL (초 단위)
*/
void saveImages(Long eventDraftId, List<RedisImageData> images, long ttlSeconds);
/**
* 이미지 삭제
*
* @param eventDraftId 이벤트 초안 ID
* @param style 이미지 스타일
* @param platform 플랫폼
*/
void deleteImage(Long eventDraftId, ImageStyle style, Platform platform);
}

19
content-service/src/main/java/com/kt/event/content/biz/usecase/out/JobReader.java Normal file
View File

@ -0,0 +1,19 @@
package com.kt.event.content.biz.usecase.out;
import com.kt.event.content.biz.dto.RedisJobData;
import java.util.Optional;
/**
* Job 조회 Port (Output Port)
*/
public interface JobReader {
/**
* Job 조회
*
* @param jobId Job ID
* @return Job 데이터
*/
Optional<RedisJobData> getJob(String jobId);
}

42
content-service/src/main/java/com/kt/event/content/biz/usecase/out/JobWriter.java Normal file
View File

@ -0,0 +1,42 @@
package com.kt.event.content.biz.usecase.out;
import com.kt.event.content.biz.dto.RedisJobData;
/**
* Job 저장 Port (Output Port)
*/
public interface JobWriter {
/**
* Job 생성/저장
*
* @param jobData Job 데이터
* @param ttlSeconds TTL (초 단위)
*/
void saveJob(RedisJobData jobData, long ttlSeconds);
/**
* Job 상태 업데이트
*
* @param jobId Job ID
* @param status 상태
* @param progress 진행률 (0-100)
*/
void updateJobStatus(String jobId, String status, Integer progress);
/**
* Job 결과 메시지 업데이트
*
* @param jobId Job ID
* @param resultMessage 결과 메시지
*/
void updateJobResult(String jobId, String resultMessage);
/**
* Job 에러 메시지 업데이트
*
* @param jobId Job ID
* @param errorMessage 에러 메시지
*/
void updateJobError(String jobId, String errorMessage);
}

19
content-service/src/main/java/com/kt/event/content/biz/usecase/out/RedisAIDataReader.java Normal file
View File

@ -0,0 +1,19 @@
package com.kt.event.content.biz.usecase.out;
import java.util.Map;
import java.util.Optional;
/**
* Redis AI 데이터 조회 포트
* Event Service가 저장한 AI 추천 데이터를 읽음
*/
public interface RedisAIDataReader {
/**
* AI 추천 데이터 조회
*
* @param eventDraftId 이벤트 초안 ID
* @return AI 추천 데이터 (JSON 형태의 Map)
*/
Optional<Map<String, Object>> getAIRecommendation(Long eventDraftId);
}

21
content-service/src/main/java/com/kt/event/content/biz/usecase/out/RedisImageWriter.java Normal file
View File

@ -0,0 +1,21 @@
package com.kt.event.content.biz.usecase.out;
import com.kt.event.content.biz.domain.GeneratedImage;
import java.util.List;
/**
* Redis 이미지 데이터 저장 포트
* 생성된 이미지 정보를 Redis에 캐싱
*/
public interface RedisImageWriter {
/**
* 이미지 목록 캐싱
*
* @param eventDraftId 이벤트 초안 ID
* @param images 이미지 목록
* @param ttlSeconds TTL (초)
*/
void cacheImages(Long eventDraftId, List<GeneratedImage> images, long ttlSeconds);
}

21
content-service/src/main/java/com/kt/event/content/infra/ContentApplication.java Normal file
View File

@ -0,0 +1,21 @@
package com.kt.event.content.infra;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;
/**
* Content Service Application
* Phase 3: JPA removed, using Redis for storage
*/
@SpringBootApplication(scanBasePackages = {
"com.kt.event.content",
"com.kt.event.common"
})
@EnableAsync
public class ContentApplication {
public static void main(String[] args) {
SpringApplication.run(ContentApplication.class, args);
}
}

60
content-service/src/main/java/com/kt/event/content/infra/config/RedisConfig.java Normal file
View File

@ -0,0 +1,60 @@
package com.kt.event.content.infra.config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* Redis 설정 (Production 환경용)
* Local/Test 환경에서는 Mock Gateway 사용
*/
@Configuration
@Profile({"!local", "!test"})
public class RedisConfig {
@Value("${spring.data.redis.host}")
private String host;
@Value("${spring.data.redis.port}")
private int port;
@Value("${spring.data.redis.password:}")
private String password;
@Bean
public RedisConnectionFactory redisConnectionFactory() {
RedisStandaloneConfiguration config = new RedisStandaloneConfiguration(host, port);
// 패스워드가 있는 경우에만 설정
if (password != null && !password.isEmpty()) {
config.setPassword(password);
}
return new LettuceConnectionFactory(config);
}
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(connectionFactory);
// String serializer for keys
template.setKeySerializer(new StringRedisSerializer());
template.setHashKeySerializer(new StringRedisSerializer());
// JSON serializer for values
GenericJackson2JsonRedisSerializer serializer = new GenericJackson2JsonRedisSerializer();
template.setValueSerializer(serializer);
template.setHashValueSerializer(serializer);
template.afterPropertiesSet();
return template;
}
}

39
content-service/src/main/java/com/kt/event/content/infra/config/SecurityConfig.java Normal file
View File

@ -0,0 +1,39 @@
package com.kt.event.content.infra.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
/**
* Spring Security 설정
* API 테스트를 위해 일단 모든 요청 허용 (추후 JWT 인증 추가)
*/
@Configuration
@EnableWebSecurity
public class SecurityConfig {
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
http
// CSRF 비활성화 (REST API는 CSRF 불필요)
.csrf(AbstractHttpConfigurer::disable)
// 세션 사용 안 함 (JWT 기반 인증)
.sessionManagement(session ->
session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)
)
// 모든 요청 허용 (테스트용, 추후 JWT 필터 추가 필요)
.authorizeHttpRequests(auth -> auth
.requestMatchers("/swagger-ui/**", "/v3/api-docs/**").permitAll()
.requestMatchers("/actuator/**").permitAll()
.anyRequest().permitAll() // TODO: 추후 authenticated()로 변경
);
return http.build();
}
}

50
content-service/src/main/java/com/kt/event/content/infra/config/SwaggerConfig.java Normal file
View File

@ -0,0 +1,50 @@
package com.kt.event.content.infra.config;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Contact;
import io.swagger.v3.oas.models.info.Info;
import io.swagger.v3.oas.models.servers.Server;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.List;
/**
* Swagger/OpenAPI 설정
*/
@Configuration
public class SwaggerConfig {
@Bean
public OpenAPI openAPI() {
return new OpenAPI()
.info(new Info()
.title("Content Service API")
.version("1.0.0")
.description("""
# KT AI 기반 소상공인 이벤트 자동 생성 서비스 - Content Service API
## 주요 기능
- **SNS 이미지 생성**: AI 기반 이벤트 이미지 자동 생성
- **콘텐츠 편집**: 생성된 이미지 조회, 재생성, 삭제
- **3가지 스타일**: 심플(SIMPLE), 화려한(FANCY), 트렌디(TRENDY)
- **3개 플랫폼 최적화**: Instagram (1080x1080), Naver (800x600), Kakao (800x800)
""")
.contact(new Contact()
.name("Digital Garage Team")
.email("support@kt-event-marketing.com")
)
)
.servers(List.of(
new Server()
.url("http://localhost:8084")
.description("Local Development Server"),
new Server()
.url("https://dev-api.kt-event-marketing.com/content/v1")
.description("Development Server"),
new Server()
.url("https://api.kt-event-marketing.com/content/v1")
.description("Production Server")
));
}
}

530
content-service/src/main/java/com/kt/event/content/infra/gateway/RedisGateway.java Normal file
View File

@ -0,0 +1,530 @@
package com.kt.event.content.infra.gateway;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.kt.event.content.biz.domain.Content;
import com.kt.event.content.biz.domain.GeneratedImage;
import com.kt.event.content.biz.domain.ImageStyle;
import com.kt.event.content.biz.domain.Job;
import com.kt.event.content.biz.domain.Platform;
import com.kt.event.content.biz.dto.RedisImageData;
import com.kt.event.content.biz.dto.RedisJobData;
import com.kt.event.content.biz.usecase.out.ContentReader;
import com.kt.event.content.biz.usecase.out.ContentWriter;
import com.kt.event.content.biz.usecase.out.ImageReader;
import com.kt.event.content.biz.usecase.out.ImageWriter;
import com.kt.event.content.biz.usecase.out.JobReader;
import com.kt.event.content.biz.usecase.out.JobWriter;
import com.kt.event.content.biz.usecase.out.RedisAIDataReader;
import com.kt.event.content.biz.usecase.out.RedisImageWriter;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Profile;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
/**
* Redis Gateway 구현체 (Production 환경용)
*
* Local/Test 환경에서는 MockRedisGateway 사용
*/
@Slf4j
@Component
@Profile({"!local", "!test"})
@RequiredArgsConstructor
public class RedisGateway implements RedisAIDataReader, RedisImageWriter, ImageWriter, ImageReader, JobWriter, JobReader, ContentReader, ContentWriter {
private final RedisTemplate<String, Object> redisTemplate;
private final ObjectMapper objectMapper;
private static final String AI_DATA_KEY_PREFIX = "ai:event:";
private static final String IMAGE_URL_KEY_PREFIX = "image:url:";
private static final Duration DEFAULT_TTL = Duration.ofHours(24);
@Override
public Optional<Map<String, Object>> getAIRecommendation(Long eventDraftId) {
try {
String key = AI_DATA_KEY_PREFIX + eventDraftId;
Object data = redisTemplate.opsForValue().get(key);
if (data == null) {
log.warn("AI 이벤트 데이터를 찾을 수 없음: eventDraftId={}", eventDraftId);
return Optional.empty();
}
@SuppressWarnings("unchecked")
Map<String, Object> aiData = objectMapper.convertValue(data, Map.class);
return Optional.of(aiData);
} catch (Exception e) {
log.error("AI 이벤트 데이터 조회 실패: eventDraftId={}", eventDraftId, e);
return Optional.empty();
}
}
@Override
public void cacheImages(Long eventDraftId, List<GeneratedImage> images, long ttlSeconds) {
try {
String key = IMAGE_URL_KEY_PREFIX + eventDraftId;
// 이미지 목록을 캐싱
redisTemplate.opsForValue().set(key, images, Duration.ofSeconds(ttlSeconds));
log.info("이미지 목록 캐싱 완료: eventDraftId={}, count={}, ttl={}초",
eventDraftId, images.size(), ttlSeconds);
} catch (Exception e) {
log.error("이미지 목록 캐싱 실패: eventDraftId={}", eventDraftId, e);
}
}
/**
* 이미지 URL 캐시 삭제
*/
public void deleteImageUrl(Long eventDraftId) {
try {
String key = IMAGE_URL_KEY_PREFIX + eventDraftId;
redisTemplate.delete(key);
log.info("이미지 URL 캐시 삭제: eventDraftId={}", eventDraftId);
} catch (Exception e) {
log.error("이미지 URL 캐시 삭제 실패: eventDraftId={}", eventDraftId, e);
}
}
/**
* AI 이벤트 데이터 캐시 삭제
*/
public void deleteAIEventData(Long eventDraftId) {
try {
String key = AI_DATA_KEY_PREFIX + eventDraftId;
redisTemplate.delete(key);
log.info("AI 이벤트 데이터 캐시 삭제: eventDraftId={}", eventDraftId);
} catch (Exception e) {
log.error("AI 이벤트 데이터 캐시 삭제 실패: eventDraftId={}", eventDraftId, e);
}
}
// ==================== 이미지 CRUD ====================
private static final String IMAGE_KEY_PREFIX = "content:image:";
/**
* 이미지 저장
* Key: content:image:{eventDraftId}:{style}:{platform}
*/
public void saveImage(RedisImageData imageData, long ttlSeconds) {
try {
String key = buildImageKey(imageData.getEventDraftId(), imageData.getStyle(), imageData.getPlatform());
String json = objectMapper.writeValueAsString(imageData);
redisTemplate.opsForValue().set(key, json, Duration.ofSeconds(ttlSeconds));
log.info("이미지 저장 완료: key={}, ttl={}초", key, ttlSeconds);
} catch (Exception e) {
log.error("이미지 저장 실패: eventDraftId={}, style={}, platform={}",
imageData.getEventDraftId(), imageData.getStyle(), imageData.getPlatform(), e);
}
}
/**
* 특정 이미지 조회
*/
public Optional<RedisImageData> getImage(Long eventDraftId, ImageStyle style, Platform platform) {
try {
String key = buildImageKey(eventDraftId, style, platform);
Object data = redisTemplate.opsForValue().get(key);
if (data == null) {
log.warn("이미지를 찾을 수 없음: key={}", key);
return Optional.empty();
}
RedisImageData imageData = objectMapper.readValue(data.toString(), RedisImageData.class);
return Optional.of(imageData);
} catch (Exception e) {
log.error("이미지 조회 실패: eventDraftId={}, style={}, platform={}", eventDraftId, style, platform, e);
return Optional.empty();
}
}
/**
* 이벤트의 모든 이미지 조회
*/
public List<RedisImageData> getImagesByEventId(Long eventDraftId) {
try {
String pattern = IMAGE_KEY_PREFIX + eventDraftId + ":*";
var keys = redisTemplate.keys(pattern);
if (keys == null || keys.isEmpty()) {
log.warn("이벤트 이미지를 찾을 수 없음: eventDraftId={}", eventDraftId);
return new ArrayList<>();
}
List<RedisImageData> images = new ArrayList<>();
for (Object key : keys) {
Object data = redisTemplate.opsForValue().get(key);
if (data != null) {
RedisImageData imageData = objectMapper.readValue(data.toString(), RedisImageData.class);
images.add(imageData);
}
}
log.info("이벤트 이미지 조회 완료: eventDraftId={}, count={}", eventDraftId, images.size());
return images;
} catch (Exception e) {
log.error("이벤트 이미지 조회 실패: eventDraftId={}", eventDraftId, e);
return new ArrayList<>();
}
}
/**
* 이미지 삭제
*/
public void deleteImage(Long eventDraftId, ImageStyle style, Platform platform) {
try {
String key = buildImageKey(eventDraftId, style, platform);
redisTemplate.delete(key);
log.info("이미지 삭제 완료: key={}", key);
} catch (Exception e) {
log.error("이미지 삭제 실패: eventDraftId={}, style={}, platform={}", eventDraftId, style, platform, e);
}
}
/**
* 여러 이미지 저장
*/
public void saveImages(Long eventDraftId, List<RedisImageData> images, long ttlSeconds) {
images.forEach(image -> saveImage(image, ttlSeconds));
log.info("여러 이미지 저장 완료: eventDraftId={}, count={}", eventDraftId, images.size());
}
/**
* 이미지 Key 생성
*/
private String buildImageKey(Long eventDraftId, ImageStyle style, Platform platform) {
return IMAGE_KEY_PREFIX + eventDraftId + ":" + style.name() + ":" + platform.name();
}
// ==================== Job 상태 관리 ====================
private static final String JOB_KEY_PREFIX = "job:";
/**
* Job 생성/저장
* Key: job:{jobId}
*/
public void saveJob(RedisJobData jobData, long ttlSeconds) {
try {
String key = JOB_KEY_PREFIX + jobData.getId();
// Hash 형태로 저장
Map<String, String> jobFields = Map.of(
"id", jobData.getId(),
"eventDraftId", String.valueOf(jobData.getEventDraftId()),
"jobType", jobData.getJobType(),
"status", jobData.getStatus(),
"progress", String.valueOf(jobData.getProgress()),
"resultMessage", jobData.getResultMessage() != null ? jobData.getResultMessage() : "",
"errorMessage", jobData.getErrorMessage() != null ? jobData.getErrorMessage() : "",
"createdAt", jobData.getCreatedAt().toString(),
"updatedAt", jobData.getUpdatedAt().toString()
);
redisTemplate.opsForHash().putAll(key, jobFields);
redisTemplate.expire(key, Duration.ofSeconds(ttlSeconds));
log.info("Job 저장 완료: jobId={}, status={}, ttl={}초", jobData.getId(), jobData.getStatus(), ttlSeconds);
} catch (Exception e) {
log.error("Job 저장 실패: jobId={}", jobData.getId(), e);
}
}
/**
* Job 조회
*/
public Optional<RedisJobData> getJob(String jobId) {
try {
String key = JOB_KEY_PREFIX + jobId;
Map<Object, Object> jobFields = redisTemplate.opsForHash().entries(key);
if (jobFields.isEmpty()) {
log.warn("Job을 찾을 수 없음: jobId={}", jobId);
return Optional.empty();
}
RedisJobData jobData = RedisJobData.builder()
.id(getString(jobFields, "id"))
.eventDraftId(getLong(jobFields, "eventDraftId"))
.jobType(getString(jobFields, "jobType"))
.status(getString(jobFields, "status"))
.progress(getInteger(jobFields, "progress"))
.resultMessage(getString(jobFields, "resultMessage"))
.errorMessage(getString(jobFields, "errorMessage"))
.createdAt(getLocalDateTime(jobFields, "createdAt"))
.updatedAt(getLocalDateTime(jobFields, "updatedAt"))
.build();
return Optional.of(jobData);
} catch (Exception e) {
log.error("Job 조회 실패: jobId={}", jobId, e);
return Optional.empty();
}
}
/**
* Job 상태 업데이트
*/
public void updateJobStatus(String jobId, String status, Integer progress) {
try {
String key = JOB_KEY_PREFIX + jobId;
redisTemplate.opsForHash().put(key, "status", status);
redisTemplate.opsForHash().put(key, "progress", String.valueOf(progress));
redisTemplate.opsForHash().put(key, "updatedAt", LocalDateTime.now().toString());
log.info("Job 상태 업데이트: jobId={}, status={}, progress={}", jobId, status, progress);
} catch (Exception e) {
log.error("Job 상태 업데이트 실패: jobId={}", jobId, e);
}
}
/**
* Job 결과 메시지 업데이트
*/
public void updateJobResult(String jobId, String resultMessage) {
try {
String key = JOB_KEY_PREFIX + jobId;
redisTemplate.opsForHash().put(key, "resultMessage", resultMessage);
redisTemplate.opsForHash().put(key, "updatedAt", LocalDateTime.now().toString());
log.info("Job 결과 업데이트: jobId={}, resultMessage={}", jobId, resultMessage);
} catch (Exception e) {
log.error("Job 결과 업데이트 실패: jobId={}", jobId, e);
}
}
/**
* Job 에러 메시지 업데이트
*/
public void updateJobError(String jobId, String errorMessage) {
try {
String key = JOB_KEY_PREFIX + jobId;
redisTemplate.opsForHash().put(key, "errorMessage", errorMessage);
redisTemplate.opsForHash().put(key, "status", "FAILED");
redisTemplate.opsForHash().put(key, "updatedAt", LocalDateTime.now().toString());
log.info("Job 에러 업데이트: jobId={}, errorMessage={}", jobId, errorMessage);
} catch (Exception e) {
log.error("Job 에러 업데이트 실패: jobId={}", jobId, e);
}
}
// ==================== Helper Methods ====================
private String getString(Map<Object, Object> map, String key) {
Object value = map.get(key);
return value != null ? value.toString() : null;
}
private Long getLong(Map<Object, Object> map, String key) {
String value = getString(map, key);
return value != null && !value.isEmpty() ? Long.parseLong(value) : null;
}
private Integer getInteger(Map<Object, Object> map, String key) {
String value = getString(map, key);
return value != null && !value.isEmpty() ? Integer.parseInt(value) : null;
}
private LocalDateTime getLocalDateTime(Map<Object, Object> map, String key) {
String value = getString(map, key);
return value != null && !value.isEmpty() ? LocalDateTime.parse(value) : null;
}
// ==================== ContentReader 구현 ====================
private static final String CONTENT_META_KEY_PREFIX = "content:meta:";
private static final String IMAGE_BY_ID_KEY_PREFIX = "content:image:id:";
private static final String IMAGE_IDS_SET_KEY_PREFIX = "content:images:";
@Override
public Optional<Content> findByEventDraftIdWithImages(Long eventDraftId) {
try {
String contentKey = CONTENT_META_KEY_PREFIX + eventDraftId;
Map<Object, Object> contentFields = redisTemplate.opsForHash().entries(contentKey);
if (contentFields.isEmpty()) {
log.warn("Content를 찾을 수 없음: eventDraftId={}", eventDraftId);
return Optional.empty();
}
// 이미지 목록 조회
List<GeneratedImage> images = findImagesByEventDraftId(eventDraftId);
// Content 재구성
Content content = Content.builder()
.id(getLong(contentFields, "id"))
.eventDraftId(getLong(contentFields, "eventDraftId"))
.eventTitle(getString(contentFields, "eventTitle"))
.eventDescription(getString(contentFields, "eventDescription"))
.images(images)
.createdAt(getLocalDateTime(contentFields, "createdAt"))
.updatedAt(getLocalDateTime(contentFields, "updatedAt"))
.build();
return Optional.of(content);
} catch (Exception e) {
log.error("Content 조회 실패: eventDraftId={}", eventDraftId, e);
return Optional.empty();
}
}
@Override
public Optional<GeneratedImage> findImageById(Long imageId) {
try {
String key = IMAGE_BY_ID_KEY_PREFIX + imageId;
Object data = redisTemplate.opsForValue().get(key);
if (data == null) {
log.warn("이미지를 찾을 수 없음: imageId={}", imageId);
return Optional.empty();
}
GeneratedImage image = objectMapper.readValue(data.toString(), GeneratedImage.class);
return Optional.of(image);
} catch (Exception e) {
log.error("이미지 조회 실패: imageId={}", imageId, e);
return Optional.empty();
}
}
@Override
public List<GeneratedImage> findImagesByEventDraftId(Long eventDraftId) {
try {
String setKey = IMAGE_IDS_SET_KEY_PREFIX + eventDraftId;
var imageIdSet = redisTemplate.opsForSet().members(setKey);
if (imageIdSet == null || imageIdSet.isEmpty()) {
log.info("이미지 목록이 비어있음: eventDraftId={}", eventDraftId);
return new ArrayList<>();
}
List<GeneratedImage> images = new ArrayList<>();
for (Object imageIdObj : imageIdSet) {
Long imageId = Long.valueOf(imageIdObj.toString());
findImageById(imageId).ifPresent(images::add);
}
log.info("이미지 목록 조회 완료: eventDraftId={}, count={}", eventDraftId, images.size());
return images;
} catch (Exception e) {
log.error("이미지 목록 조회 실패: eventDraftId={}", eventDraftId, e);
return new ArrayList<>();
}
}
// ==================== ContentWriter 구현 ====================
private static Long nextContentId = 1L;
private static Long nextImageId = 1L;
@Override
public Content save(Content content) {
try {
Long id = content.getId() != null ? content.getId() : nextContentId++;
String contentKey = CONTENT_META_KEY_PREFIX + content.getEventDraftId();
// Content 메타 정보 저장
Map<String, String> contentFields = new java.util.HashMap<>();
contentFields.put("id", String.valueOf(id));
contentFields.put("eventDraftId", String.valueOf(content.getEventDraftId()));
contentFields.put("eventTitle", content.getEventTitle() != null ? content.getEventTitle() : "");
contentFields.put("eventDescription", content.getEventDescription() != null ? content.getEventDescription() : "");
contentFields.put("createdAt", content.getCreatedAt() != null ? content.getCreatedAt().toString() : LocalDateTime.now().toString());
contentFields.put("updatedAt", content.getUpdatedAt() != null ? content.getUpdatedAt().toString() : LocalDateTime.now().toString());
redisTemplate.opsForHash().putAll(contentKey, contentFields);
redisTemplate.expire(contentKey, DEFAULT_TTL);
// Content 재구성하여 반환
Content savedContent = Content.builder()
.id(id)
.eventDraftId(content.getEventDraftId())
.eventTitle(content.getEventTitle())
.eventDescription(content.getEventDescription())
.images(content.getImages())
.createdAt(content.getCreatedAt())
.updatedAt(content.getUpdatedAt())
.build();
log.info("Content 저장 완료: contentId={}, eventDraftId={}", id, content.getEventDraftId());
return savedContent;
} catch (Exception e) {
log.error("Content 저장 실패: eventDraftId={}", content.getEventDraftId(), e);
throw new RuntimeException("Content 저장 실패", e);
}
}
@Override
public GeneratedImage saveImage(GeneratedImage image) {
try {
Long imageId = image.getId() != null ? image.getId() : nextImageId++;
// GeneratedImage 저장
String imageKey = IMAGE_BY_ID_KEY_PREFIX + imageId;
GeneratedImage savedImage = GeneratedImage.builder()
.id(imageId)
.eventDraftId(image.getEventDraftId())
.style(image.getStyle())
.platform(image.getPlatform())
.cdnUrl(image.getCdnUrl())
.prompt(image.getPrompt())
.selected(image.isSelected())
.createdAt(image.getCreatedAt() != null ? image.getCreatedAt() : LocalDateTime.now())
.updatedAt(image.getUpdatedAt() != null ? image.getUpdatedAt() : LocalDateTime.now())
.build();
String json = objectMapper.writeValueAsString(savedImage);
redisTemplate.opsForValue().set(imageKey, json, DEFAULT_TTL);
// Image ID를 Set에 추가
String setKey = IMAGE_IDS_SET_KEY_PREFIX + image.getEventDraftId();
redisTemplate.opsForSet().add(setKey, imageId);
redisTemplate.expire(setKey, DEFAULT_TTL);
log.info("이미지 저장 완료: imageId={}, eventDraftId={}", imageId, image.getEventDraftId());
return savedImage;
} catch (Exception e) {
log.error("이미지 저장 실패: eventDraftId={}", image.getEventDraftId(), e);
throw new RuntimeException("이미지 저장 실패", e);
}
}
@Override
public void deleteImageById(Long imageId) {
try {
// 이미지 조회
Optional<GeneratedImage> imageOpt = findImageById(imageId);
if (imageOpt.isEmpty()) {
log.warn("삭제할 이미지를 찾을 수 없음: imageId={}", imageId);
return;
}
GeneratedImage image = imageOpt.get();
// Image 삭제
String imageKey = IMAGE_BY_ID_KEY_PREFIX + imageId;
redisTemplate.delete(imageKey);
// Set에서 Image ID 제거
String setKey = IMAGE_IDS_SET_KEY_PREFIX + image.getEventDraftId();
redisTemplate.opsForSet().remove(setKey, imageId);
log.info("이미지 삭제 완료: imageId={}, eventDraftId={}", imageId, image.getEventDraftId());
} catch (Exception e) {
log.error("이미지 삭제 실패: imageId={}", imageId, e);
throw new RuntimeException("이미지 삭제 실패", e);
}
}
}

31
content-service/src/main/java/com/kt/event/content/infra/gateway/mock/MockCDNUploader.java Normal file
View File

@ -0,0 +1,31 @@
package com.kt.event.content.infra.gateway.mock;
import com.kt.event.content.biz.usecase.out.CDNUploader;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;
/**
* Mock CDN Uploader (테스트용)
* 실제 Azure Blob Storage 연동 전까지 사용
*/
@Slf4j
@Component
@Profile({"local", "test"})
public class MockCDNUploader implements CDNUploader {
private static final String MOCK_CDN_BASE_URL = "https://cdn.kt-event.com/images/mock";
@Override
public String upload(byte[] imageData, String fileName) {
log.info("[MOCK] CDN에 이미지 업로드: fileName={}, size={} bytes",
fileName, imageData.length);
// Mock CDN URL 생성
String mockUrl = String.format("%s/%s", MOCK_CDN_BASE_URL, fileName);
log.info("[MOCK] 업로드된 CDN URL: {}", mockUrl);
return mockUrl;
}
}

41
content-service/src/main/java/com/kt/event/content/infra/gateway/mock/MockImageGenerator.java Normal file
View File

@ -0,0 +1,41 @@
package com.kt.event.content.infra.gateway.mock;
import com.kt.event.content.biz.domain.ImageStyle;
import com.kt.event.content.biz.domain.Platform;
import com.kt.event.content.biz.usecase.out.ImageGeneratorCaller;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;
/**
* Mock Image Generator (테스트용)
* 실제 AI 이미지 생성 API 연동 전까지 사용
*/
@Slf4j
@Component
@Profile({"local", "test"})
public class MockImageGenerator implements ImageGeneratorCaller {
@Override
public byte[] generateImage(String prompt, ImageStyle style, Platform platform) {
log.info("[MOCK] AI 이미지 생성: prompt='{}', style={}, platform={}",
prompt, style, platform);
// Mock: 빈 바이트 배열 반환 (실제로는 AI가 생성한 이미지 데이터)
byte[] mockImageData = createMockImageData(style, platform);
log.info("[MOCK] 이미지 생성 완료: size={} bytes", mockImageData.length);
return mockImageData;
}
/**
* Mock 이미지 데이터 생성
* 실제로는 PNG/JPEG 이미지 바이너리 데이터
*/
private byte[] createMockImageData(ImageStyle style, Platform platform) {
// 간단한 Mock 데이터 생성 (실제로는 이미지 바이너리)
String mockContent = String.format("MOCK_IMAGE_DATA[style=%s,platform=%s]", style, platform);
return mockContent.getBytes();
}
}

430
content-service/src/main/java/com/kt/event/content/infra/gateway/mock/MockRedisGateway.java Normal file
View File

@ -0,0 +1,430 @@
package com.kt.event.content.infra.gateway.mock;
import com.kt.event.content.biz.domain.Content;
import com.kt.event.content.biz.domain.GeneratedImage;
import com.kt.event.content.biz.domain.ImageStyle;
import com.kt.event.content.biz.domain.Job;
import com.kt.event.content.biz.domain.Platform;
import com.kt.event.content.biz.dto.RedisImageData;
import com.kt.event.content.biz.dto.RedisJobData;
import com.kt.event.content.biz.usecase.out.ContentReader;
import com.kt.event.content.biz.usecase.out.ContentWriter;
import com.kt.event.content.biz.usecase.out.ImageReader;
import com.kt.event.content.biz.usecase.out.ImageWriter;
import com.kt.event.content.biz.usecase.out.JobReader;
import com.kt.event.content.biz.usecase.out.JobWriter;
import com.kt.event.content.biz.usecase.out.RedisAIDataReader;
import com.kt.event.content.biz.usecase.out.RedisImageWriter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
/**
* Mock Redis Gateway (테스트용)
* 실제 Redis 연동 전까지 사용
*/
@Slf4j
@Component
@Primary
@Profile({"local", "test"})
public class MockRedisGateway implements RedisAIDataReader, RedisImageWriter, ImageWriter, ImageReader, JobWriter, JobReader, ContentReader, ContentWriter {
private final Map<Long, Map<String, Object>> aiDataCache = new HashMap<>();
// In-memory storage for contents, images, and jobs
private final Map<Long, Content> contentStorage = new ConcurrentHashMap<>();
private final Map<Long, GeneratedImage> imageByIdStorage = new ConcurrentHashMap<>();
private final Map<String, RedisImageData> imageStorage = new ConcurrentHashMap<>();
private final Map<String, RedisJobData> jobStorage = new ConcurrentHashMap<>();
// ========================================
// RedisAIDataReader 구현
// ========================================
@Override
public Optional<Map<String, Object>> getAIRecommendation(Long eventDraftId) {
log.info("[MOCK] Redis에서 AI 추천 데이터 조회: eventDraftId={}", eventDraftId);
// Mock 데이터 반환
Map<String, Object> mockData = new HashMap<>();
mockData.put("title", "테스트 이벤트 제목");
mockData.put("description", "테스트 이벤트 설명");
mockData.put("brandColor", "#FF5733");
return Optional.of(mockData);
}
// ========================================
// RedisImageWriter 구현
// ========================================
@Override
public void cacheImages(Long eventDraftId, List<GeneratedImage> images, long ttlSeconds) {
log.info("[MOCK] Redis에 이미지 캐싱: eventDraftId={}, count={}, ttl={}초",
eventDraftId, images.size(), ttlSeconds);
}
// ==================== 이미지 CRUD ====================
private static final String IMAGE_KEY_PREFIX = "content:image:";
/**
* 이미지 저장
*/
public void saveImage(RedisImageData imageData, long ttlSeconds) {
try {
String key = buildImageKey(imageData.getEventDraftId(), imageData.getStyle(), imageData.getPlatform());
imageStorage.put(key, imageData);
log.info("[MOCK] 이미지 저장 완료: key={}, ttl={}초", key, ttlSeconds);
} catch (Exception e) {
log.error("[MOCK] 이미지 저장 실패: eventDraftId={}, style={}, platform={}",
imageData.getEventDraftId(), imageData.getStyle(), imageData.getPlatform(), e);
}
}
/**
* 특정 이미지 조회
*/
public Optional<RedisImageData> getImage(Long eventDraftId, ImageStyle style, Platform platform) {
try {
String key = buildImageKey(eventDraftId, style, platform);
RedisImageData imageData = imageStorage.get(key);
if (imageData == null) {
log.warn("[MOCK] 이미지를 찾을 수 없음: key={}", key);
return Optional.empty();
}
return Optional.of(imageData);
} catch (Exception e) {
log.error("[MOCK] 이미지 조회 실패: eventDraftId={}, style={}, platform={}",
eventDraftId, style, platform, e);
return Optional.empty();
}
}
/**
* 이벤트의 모든 이미지 조회
*/
public List<RedisImageData> getImagesByEventId(Long eventDraftId) {
try {
String pattern = IMAGE_KEY_PREFIX + eventDraftId + ":";
List<RedisImageData> images = imageStorage.entrySet().stream()
.filter(entry -> entry.getKey().startsWith(pattern))
.map(Map.Entry::getValue)
.collect(Collectors.toList());
log.info("[MOCK] 이벤트 이미지 조회 완료: eventDraftId={}, count={}", eventDraftId, images.size());
return images;
} catch (Exception e) {
log.error("[MOCK] 이벤트 이미지 조회 실패: eventDraftId={}", eventDraftId, e);
return new ArrayList<>();
}
}
/**
* 이미지 삭제
*/
public void deleteImage(Long eventDraftId, ImageStyle style, Platform platform) {
try {
String key = buildImageKey(eventDraftId, style, platform);
imageStorage.remove(key);
log.info("[MOCK] 이미지 삭제 완료: key={}", key);
} catch (Exception e) {
log.error("[MOCK] 이미지 삭제 실패: eventDraftId={}, style={}, platform={}",
eventDraftId, style, platform, e);
}
}
/**
* 여러 이미지 저장
*/
public void saveImages(Long eventDraftId, List<RedisImageData> images, long ttlSeconds) {
images.forEach(image -> saveImage(image, ttlSeconds));
log.info("[MOCK] 여러 이미지 저장 완료: eventDraftId={}, count={}", eventDraftId, images.size());
}
/**
* 이미지 Key 생성
*/
private String buildImageKey(Long eventDraftId, ImageStyle style, Platform platform) {
return IMAGE_KEY_PREFIX + eventDraftId + ":" + style.name() + ":" + platform.name();
}
// ==================== Job 상태 관리 ====================
private static final String JOB_KEY_PREFIX = "job:";
/**
* Job 생성/저장
*/
public void saveJob(RedisJobData jobData, long ttlSeconds) {
try {
String key = JOB_KEY_PREFIX + jobData.getId();
jobStorage.put(key, jobData);
log.info("[MOCK] Job 저장 완료: jobId={}, status={}, ttl={}초",
jobData.getId(), jobData.getStatus(), ttlSeconds);
} catch (Exception e) {
log.error("[MOCK] Job 저장 실패: jobId={}", jobData.getId(), e);
}
}
/**
* Job 조회
*/
public Optional<RedisJobData> getJob(String jobId) {
try {
String key = JOB_KEY_PREFIX + jobId;
RedisJobData jobData = jobStorage.get(key);
if (jobData == null) {
log.warn("[MOCK] Job을 찾을 수 없음: jobId={}", jobId);
return Optional.empty();
}
return Optional.of(jobData);
} catch (Exception e) {
log.error("[MOCK] Job 조회 실패: jobId={}", jobId, e);
return Optional.empty();
}
}
/**
* Job 상태 업데이트
*/
public void updateJobStatus(String jobId, String status, Integer progress) {
try {
String key = JOB_KEY_PREFIX + jobId;
RedisJobData jobData = jobStorage.get(key);
if (jobData != null) {
jobData.setStatus(status);
jobData.setProgress(progress);
jobData.setUpdatedAt(LocalDateTime.now());
jobStorage.put(key, jobData);
log.info("[MOCK] Job 상태 업데이트: jobId={}, status={}, progress={}",
jobId, status, progress);
} else {
log.warn("[MOCK] Job을 찾을 수 없어 상태 업데이트 실패: jobId={}", jobId);
}
} catch (Exception e) {
log.error("[MOCK] Job 상태 업데이트 실패: jobId={}", jobId, e);
}
}
/**
* Job 결과 메시지 업데이트
*/
public void updateJobResult(String jobId, String resultMessage) {
try {
String key = JOB_KEY_PREFIX + jobId;
RedisJobData jobData = jobStorage.get(key);
if (jobData != null) {
jobData.setResultMessage(resultMessage);
jobData.setUpdatedAt(LocalDateTime.now());
jobStorage.put(key, jobData);
log.info("[MOCK] Job 결과 업데이트: jobId={}, resultMessage={}", jobId, resultMessage);
} else {
log.warn("[MOCK] Job을 찾을 수 없어 결과 업데이트 실패: jobId={}", jobId);
}
} catch (Exception e) {
log.error("[MOCK] Job 결과 업데이트 실패: jobId={}", jobId, e);
}
}
/**
* Job 에러 메시지 업데이트
*/
public void updateJobError(String jobId, String errorMessage) {
try {
String key = JOB_KEY_PREFIX + jobId;
RedisJobData jobData = jobStorage.get(key);
if (jobData != null) {
jobData.setErrorMessage(errorMessage);
jobData.setStatus("FAILED");
jobData.setUpdatedAt(LocalDateTime.now());
jobStorage.put(key, jobData);
log.info("[MOCK] Job 에러 업데이트: jobId={}, errorMessage={}", jobId, errorMessage);
} else {
log.warn("[MOCK] Job을 찾을 수 없어 에러 업데이트 실패: jobId={}", jobId);
}
} catch (Exception e) {
log.error("[MOCK] Job 에러 업데이트 실패: jobId={}", jobId, e);
}
}
// ==================== ContentReader 구현 ====================
/**
* 이벤트 초안 ID로 콘텐츠 조회 (이미지 목록 포함)
*/
@Override
public Optional<Content> findByEventDraftIdWithImages(Long eventDraftId) {
try {
Content content = contentStorage.get(eventDraftId);
if (content == null) {
log.warn("[MOCK] Content를 찾을 수 없음: eventDraftId={}", eventDraftId);
return Optional.empty();
}
// 이미지 목록 조회 및 Content 재생성 (immutable pattern)
List<GeneratedImage> images = findImagesByEventDraftId(eventDraftId);
Content contentWithImages = Content.builder()
.id(content.getId())
.eventDraftId(content.getEventDraftId())
.eventTitle(content.getEventTitle())
.eventDescription(content.getEventDescription())
.images(images)
.createdAt(content.getCreatedAt())
.updatedAt(content.getUpdatedAt())
.build();
return Optional.of(contentWithImages);
} catch (Exception e) {
log.error("[MOCK] Content 조회 실패: eventDraftId={}", eventDraftId, e);
return Optional.empty();
}
}
/**
* 이미지 ID로 이미지 조회
*/
@Override
public Optional<GeneratedImage> findImageById(Long imageId) {
try {
GeneratedImage image = imageByIdStorage.get(imageId);
if (image == null) {
log.warn("[MOCK] 이미지를 찾을 수 없음: imageId={}", imageId);
return Optional.empty();
}
return Optional.of(image);
} catch (Exception e) {
log.error("[MOCK] 이미지 조회 실패: imageId={}", imageId, e);
return Optional.empty();
}
}
/**
* 이벤트 초안 ID로 이미지 목록 조회
*/
@Override
public List<GeneratedImage> findImagesByEventDraftId(Long eventDraftId) {
try {
return imageByIdStorage.values().stream()
.filter(image -> image.getEventDraftId().equals(eventDraftId))
.collect(Collectors.toList());
} catch (Exception e) {
log.error("[MOCK] 이미지 목록 조회 실패: eventDraftId={}", eventDraftId, e);
return new ArrayList<>();
}
}
// ==================== ContentWriter 구현 ====================
private static Long nextContentId = 1L;
private static Long nextImageId = 1L;
/**
* 콘텐츠 저장
*/
@Override
public Content save(Content content) {
try {
// ID가 없으면 생성하여 새 Content 객체 생성 (immutable pattern)
Long id = content.getId() != null ? content.getId() : nextContentId++;
Content savedContent = Content.builder()
.id(id)
.eventDraftId(content.getEventDraftId())
.eventTitle(content.getEventTitle())
.eventDescription(content.getEventDescription())
.images(content.getImages())
.createdAt(content.getCreatedAt())
.updatedAt(content.getUpdatedAt())
.build();
contentStorage.put(savedContent.getEventDraftId(), savedContent);
log.info("[MOCK] Content 저장 완료: contentId={}, eventDraftId={}",
savedContent.getId(), savedContent.getEventDraftId());
return savedContent;
} catch (Exception e) {
log.error("[MOCK] Content 저장 실패: eventDraftId={}", content.getEventDraftId(), e);
throw e;
}
}
/**
* 이미지 저장
*/
@Override
public GeneratedImage saveImage(GeneratedImage image) {
try {
// ID가 없으면 생성하여 새 GeneratedImage 객체 생성 (immutable pattern)
Long id = image.getId() != null ? image.getId() : nextImageId++;
GeneratedImage savedImage = GeneratedImage.builder()
.id(id)
.eventDraftId(image.getEventDraftId())
.style(image.getStyle())
.platform(image.getPlatform())
.cdnUrl(image.getCdnUrl())
.prompt(image.getPrompt())
.selected(image.isSelected())
.createdAt(image.getCreatedAt())
.updatedAt(image.getUpdatedAt())
.build();
imageByIdStorage.put(savedImage.getId(), savedImage);
log.info("[MOCK] 이미지 저장 완료: imageId={}, eventDraftId={}, style={}, platform={}",
savedImage.getId(), savedImage.getEventDraftId(), savedImage.getStyle(), savedImage.getPlatform());
return savedImage;
} catch (Exception e) {
log.error("[MOCK] 이미지 저장 실패: eventDraftId={}", image.getEventDraftId(), e);
throw e;
}
}
/**
* 이미지 ID로 이미지 삭제
*/
@Override
public void deleteImageById(Long imageId) {
try {
// imageByIdStorage에서 이미지 조회
GeneratedImage image = imageByIdStorage.get(imageId);
if (image == null) {
log.warn("[MOCK] 삭제할 이미지를 찾을 수 없음: imageId={}", imageId);
return;
}
// imageByIdStorage에서 삭제
imageByIdStorage.remove(imageId);
// imageStorage에서도 삭제 (Redis 캐시 스토리지)
String key = buildImageKey(image.getEventDraftId(), image.getStyle(), image.getPlatform());
imageStorage.remove(key);
log.info("[MOCK] 이미지 삭제 완료: imageId={}, eventDraftId={}, style={}, platform={}",
imageId, image.getEventDraftId(), image.getStyle(), image.getPlatform());
} catch (Exception e) {
log.error("[MOCK] 이미지 삭제 실패: imageId={}", imageId, e);
throw e;
}
}
}

176
content-service/src/main/java/com/kt/event/content/infra/web/controller/ContentController.java Normal file
View File

@ -0,0 +1,176 @@
package com.kt.event.content.infra.web.controller;
import com.kt.event.content.biz.domain.ImageStyle;
import com.kt.event.content.biz.domain.Platform;
import com.kt.event.content.biz.dto.ContentCommand;
import com.kt.event.content.biz.dto.ContentInfo;
import com.kt.event.content.biz.dto.ImageInfo;
import com.kt.event.content.biz.dto.JobInfo;
import com.kt.event.content.biz.usecase.in.DeleteImageUseCase;
import com.kt.event.content.biz.usecase.in.GenerateImagesUseCase;
import com.kt.event.content.biz.usecase.in.GetEventContentUseCase;
import com.kt.event.content.biz.usecase.in.GetImageDetailUseCase;
import com.kt.event.content.biz.usecase.in.GetImageListUseCase;
import com.kt.event.content.biz.usecase.in.GetJobStatusUseCase;
import com.kt.event.content.biz.usecase.in.RegenerateImageUseCase;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* Content Service REST API Controller
*
* API 명세: content-service-api.yaml
* - 이미지 생성 요청 및 Job 상태 조회
* - 생성된 콘텐츠 조회 및 관리
* - 이미지 재생성 및 삭제
*/
@Slf4j
@RestController
@RequestMapping("/api/v1/content")
@RequiredArgsConstructor
public class ContentController {
private final GenerateImagesUseCase generateImagesUseCase;
private final GetJobStatusUseCase getJobStatusUseCase;
private final GetEventContentUseCase getEventContentUseCase;
private final GetImageListUseCase getImageListUseCase;
private final GetImageDetailUseCase getImageDetailUseCase;
private final RegenerateImageUseCase regenerateImageUseCase;
private final DeleteImageUseCase deleteImageUseCase;
/**
* POST /api/v1/content/images/generate
* SNS 이미지 생성 요청 (비동기)
*
* @param command 이미지 생성 요청 정보
* @return 202 ACCEPTED - Job ID 반환
*/
@PostMapping("/images/generate")
public ResponseEntity<JobInfo> generateImages(@RequestBody ContentCommand.GenerateImages command) {
log.info("이미지 생성 요청: eventDraftId={}, styles={}, platforms={}",
command.getEventDraftId(), command.getStyles(), command.getPlatforms());
JobInfo jobInfo = generateImagesUseCase.execute(command);
return ResponseEntity.status(HttpStatus.ACCEPTED).body(jobInfo);
}
/**
* GET /api/v1/content/images/jobs/{jobId}
* 이미지 생성 작업 상태 조회 (폴링)
*
* @param jobId Job ID
* @return 200 OK - Job 상태 정보
*/
@GetMapping("/images/jobs/{jobId}")
public ResponseEntity<JobInfo> getJobStatus(@PathVariable String jobId) {
log.info("Job 상태 조회: jobId={}", jobId);
JobInfo jobInfo = getJobStatusUseCase.execute(jobId);
return ResponseEntity.ok(jobInfo);
}
/**
* GET /api/v1/content/events/{eventDraftId}
* 이벤트의 생성된 콘텐츠 조회
*
* @param eventDraftId 이벤트 초안 ID
* @return 200 OK - 콘텐츠 정보 (이미지 목록 포함)
*/
@GetMapping("/events/{eventDraftId}")
public ResponseEntity<ContentInfo> getContentByEventId(@PathVariable Long eventDraftId) {
log.info("이벤트 콘텐츠 조회: eventDraftId={}", eventDraftId);
ContentInfo contentInfo = getEventContentUseCase.execute(eventDraftId);
return ResponseEntity.ok(contentInfo);
}
/**
* GET /api/v1/content/events/{eventDraftId}/images
* 이벤트의 이미지 목록 조회 (필터링)
*
* @param eventDraftId 이벤트 초안 ID
* @param style 이미지 스타일 필터 (선택)
* @param platform 플랫폼 필터 (선택)
* @return 200 OK - 이미지 목록
*/
@GetMapping("/events/{eventDraftId}/images")
public ResponseEntity<List<ImageInfo>> getImages(
@PathVariable Long eventDraftId,
@RequestParam(required = false) String style,
@RequestParam(required = false) String platform) {
log.info("이미지 목록 조회: eventDraftId={}, style={}, platform={}", eventDraftId, style, platform);
// String -> Enum 변환
ImageStyle imageStyle = style != null ? ImageStyle.valueOf(style.toUpperCase()) : null;
Platform imagePlatform = platform != null ? Platform.valueOf(platform.toUpperCase()) : null;
List<ImageInfo> images = getImageListUseCase.execute(eventDraftId, imageStyle, imagePlatform);
return ResponseEntity.ok(images);
}
/**
* GET /api/v1/content/images/{imageId}
* 특정 이미지 상세 조회
*
* @param imageId 이미지 ID
* @return 200 OK - 이미지 상세 정보
*/
@GetMapping("/images/{imageId}")
public ResponseEntity<ImageInfo> getImageById(@PathVariable Long imageId) {
log.info("이미지 상세 조회: imageId={}", imageId);
ImageInfo imageInfo = getImageDetailUseCase.execute(imageId);
return ResponseEntity.ok(imageInfo);
}
/**
* DELETE /api/v1/content/images/{imageId}
* 생성된 이미지 삭제
*
* @param imageId 이미지 ID
* @return 204 NO CONTENT
*/
@DeleteMapping("/images/{imageId}")
public ResponseEntity<Void> deleteImage(@PathVariable Long imageId) {
log.info("이미지 삭제 요청: imageId={}", imageId);
deleteImageUseCase.execute(imageId);
return ResponseEntity.noContent().build();
}
/**
* POST /api/v1/content/images/{imageId}/regenerate
* 이미지 재생성 요청
*
* @param imageId 이미지 ID
* @param requestBody 재생성 요청 정보 (선택)
* @return 202 ACCEPTED - Job ID 반환
*/
@PostMapping("/images/{imageId}/regenerate")
public ResponseEntity<JobInfo> regenerateImage(
@PathVariable Long imageId,
@RequestBody(required = false) ContentCommand.RegenerateImage requestBody) {
log.info("이미지 재생성 요청: imageId={}", imageId);
// imageId를 포함한 command 생성
ContentCommand.RegenerateImage command = ContentCommand.RegenerateImage.builder()
.imageId(imageId)
.newPrompt(requestBody != null ? requestBody.getNewPrompt() : null)
.build();
JobInfo jobInfo = regenerateImageUseCase.execute(command);
return ResponseEntity.status(HttpStatus.ACCEPTED).body(jobInfo);
}
}

34
content-service/src/main/resources/application-dev.yml Normal file
View File

@ -0,0 +1,34 @@
spring:
application:
name: content-service
data:
redis:
host: ${REDIS_HOST:20.214.210.71}
port: ${REDIS_PORT:6379}
password: ${REDIS_PASSWORD:}
server:
port: ${SERVER_PORT:8084}
jwt:
secret: ${JWT_SECRET:kt-event-marketing-jwt-secret-key-for-authentication-and-authorization-2025}
access-token-validity: ${JWT_ACCESS_TOKEN_VALIDITY:3600000}
refresh-token-validity: ${JWT_REFRESH_TOKEN_VALIDITY:604800000}
azure:
storage:
connection-string: ${AZURE_STORAGE_CONNECTION_STRING:}
container-name: ${AZURE_CONTAINER_NAME:event-images}
logging:
level:
com.kt.event: ${LOG_LEVEL_APP:DEBUG}
root: ${LOG_LEVEL_ROOT:INFO}
file:
name: ${LOG_FILE:logs/content-service.log}
logback:
rollingpolicy:
max-file-size: 10MB
max-history: 7
total-size-cap: 100MB

43
content-service/src/main/resources/application-local.yml Normal file
View File

@ -0,0 +1,43 @@
spring:
datasource:
url: jdbc:h2:mem:contentdb
username: sa
password:
driver-class-name: org.h2.Driver
h2:
console:
enabled: true
path: /h2-console
jpa:
database-platform: org.hibernate.dialect.H2Dialect
hibernate:
ddl-auto: create-drop
show-sql: true
properties:
hibernate:
format_sql: true
dialect: org.hibernate.dialect.H2Dialect
data:
redis:
# Redis 연결 비활성화 (Mock 사용)
repositories:
enabled: false
host: localhost
port: 6379
autoconfigure:
exclude:
- org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration
- org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration
server:
port: 8084
logging:
level:
com.kt.event: DEBUG
org.hibernate.SQL: DEBUG
org.hibernate.type.descriptor.sql.BasicBinder: TRACE

34
content-service/src/main/resources/application.yml Normal file
View File

@ -0,0 +1,34 @@
spring:
application:
name: content-service
data:
redis:
host: ${REDIS_HOST:localhost}
port: ${REDIS_PORT:6379}
password: ${REDIS_PASSWORD:}
server:
port: ${SERVER_PORT:8084}
jwt:
secret: ${JWT_SECRET:dev-jwt-secret-key}
access-token-validity: ${JWT_ACCESS_TOKEN_VALIDITY:3600000}
refresh-token-validity: ${JWT_REFRESH_TOKEN_VALIDITY:604800000}
azure:
storage:
connection-string: ${AZURE_STORAGE_CONNECTION_STRING:}
container-name: ${AZURE_CONTAINER_NAME:event-images}
logging:
level:
com.kt.event: ${LOG_LEVEL_APP:DEBUG}
root: ${LOG_LEVEL_ROOT:INFO}
file:
name: ${LOG_FILE:logs/content-service.log}
logback:
rollingpolicy:
max-file-size: 10MB
max-history: 7
total-size-cap: 100MB

BIN
design/.DS_Store vendored
View File

Binary file not shown.

14
design/backend/api/content-service-api.yaml
View File

@ -61,7 +61,7 @@ tags:
description: 이미지 재생성 및 삭제 (UFR-CONT-020)
paths:
/content/images/generate:
/api/v1/content/images/generate:
post:
tags:
- Job Status
@ -71,7 +71,7 @@ paths:
## 처리 방식
- **비동기 처리**: Kafka `image-generation-job` 토픽에 Job 발행
- **폴링 조회**: jobId로 생성 상태 조회 (GET /content/images/jobs/{jobId})
- **폴링 조회**: jobId로 생성 상태 조회 (GET /api/v1/content/images/jobs/{jobId})
- **캐싱**: 동일한 eventDraftId 재요청 시 캐시 반환 (TTL 7일)
## 생성 스타일
@ -182,7 +182,7 @@ paths:
security:
- BearerAuth: []
/content/images/jobs/{jobId}:
/api/v1/content/images/jobs/{jobId}:
get:
tags:
- Job Status
@ -339,7 +339,7 @@ paths:
security:
- BearerAuth: []
/content/events/{eventDraftId}:
/api/v1/content/events/{eventDraftId}:
get:
tags:
- Content Management
@ -427,7 +427,7 @@ paths:
security:
- BearerAuth: []
/content/events/{eventDraftId}/images:
/api/v1/content/events/{eventDraftId}/images:
get:
tags:
- Content Management
@ -506,7 +506,7 @@ paths:
security:
- BearerAuth: []
/content/images/{imageId}:
/api/v1/content/images/{imageId}:
get:
tags:
- Image Management
@ -590,7 +590,7 @@ paths:
security:
- BearerAuth: []
/content/images/{imageId}/regenerate:
/api/v1/content/images/{imageId}/regenerate:
post:
tags:
- Image Management

23
design/backend/api/user-service-api.yaml
View File

@ -51,7 +51,7 @@ paths:
- JWT 토큰 자동 발급
**처리 흐름:**
1. 중복 사용자 확인 (전화번호 기반)
1. 중복 사용자 확인 (이메일/전화번호 기반)
2. 비밀번호 해싱 (bcrypt)
3. User/Store 데이터베이스 트랜잭션 처리
4. JWT 토큰 생성 및 세션 저장 (Redis)
@ -114,7 +114,7 @@ paths:
summary: 중복 사용자
value:
code: USER_001
message: 이미 가입된 전화번호입니다
message: 이미 가입된 이메일입니다
timestamp: 2025-10-22T10:30:00Z
validationError:
summary: 입력 검증 오류
@ -140,7 +140,7 @@ paths:
**유저스토리:** UFR-USER-020
**주요 기능:**
- 전화번호/비밀번호 인증
- 이메일/비밀번호 인증
- JWT 토큰 발급
- Redis 세션 저장
- 최종 로그인 시각 업데이트 (비동기)
@ -162,7 +162,7 @@ paths:
default:
summary: 로그인 요청 예시
value:
phoneNumber: "01012345678"
email: hong@example.com
password: "Password123!"
responses:
'200':
@ -191,7 +191,7 @@ paths:
summary: 인증 실패
value:
code: AUTH_001
message: 전화번호 또는 비밀번호를 확인해주세요
message: 이메일 또는 비밀번호를 확인해주세요
timestamp: 2025-10-22T10:30:00Z
/users/logout:
@ -679,14 +679,15 @@ components:
LoginRequest:
type: object
required:
- phoneNumber
- email
- password
properties:
phoneNumber:
email:
type: string
pattern: '^010\d{8}$'
description: 휴대폰 번호
example: "01012345678"
format: email
maxLength: 100
description: 이메일 주소
example: hong@example.com
password:
type: string
minLength: 8
@ -977,7 +978,7 @@ components:
message:
type: string
description: 에러 메시지
example: 이미 가입된 전화번호입니다
example: 이미 가입된 이메일입니다
timestamp:
type: string
format: date-time

270
develop/database/sql/event-service-ddl.sql Normal file
View File

@ -0,0 +1,270 @@
-- ============================================
-- Event Service Database DDL
-- ============================================
-- Description: Event Service 데이터베이스 테이블 생성 스크립트
-- Database: PostgreSQL 15+
-- Author: Event Service Team
-- Version: 1.0.0
-- Created: 2025-10-24
-- ============================================
-- UUID 확장 활성화 (PostgreSQL)
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
-- ============================================
-- 1. events 테이블
-- ============================================
-- 이벤트 마스터 테이블
-- 이벤트의 전체 생명주기(생성, 수정, 배포, 종료)를 관리
-- ============================================
CREATE TABLE IF NOT EXISTS events (
event_id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
user_id UUID NOT NULL,
store_id UUID NOT NULL,
event_name VARCHAR(200),
description TEXT,
objective VARCHAR(100) NOT NULL,
start_date DATE,
end_date DATE,
status VARCHAR(20) NOT NULL DEFAULT 'DRAFT',
selected_image_id UUID,
selected_image_url VARCHAR(500),
created_at TIMESTAMP NOT NULL, -- Managed by JPA @CreatedDate
updated_at TIMESTAMP NOT NULL, -- Managed by JPA @LastModifiedDate
-- 제약조건
CONSTRAINT chk_event_period CHECK (start_date IS NULL OR end_date IS NULL OR start_date <= end_date),
CONSTRAINT chk_event_status CHECK (status IN ('DRAFT', 'PUBLISHED', 'ENDED'))
);
-- 인덱스
CREATE INDEX idx_events_user_id ON events(user_id);
CREATE INDEX idx_events_store_id ON events(store_id);
CREATE INDEX idx_events_status ON events(status);
CREATE INDEX idx_events_created_at ON events(created_at);
-- 복합 인덱스 (쿼리 성능 최적화)
CREATE INDEX idx_events_user_status_created ON events(user_id, status, created_at DESC);
-- 주석
COMMENT ON TABLE events IS '이벤트 마스터 테이블';
COMMENT ON COLUMN events.event_id IS '이벤트 ID (PK)';
COMMENT ON COLUMN events.user_id IS '사용자 ID';
COMMENT ON COLUMN events.store_id IS '매장 ID';
COMMENT ON COLUMN events.event_name IS '이벤트명';
COMMENT ON COLUMN events.description IS '이벤트 설명';
COMMENT ON COLUMN events.objective IS '이벤트 목적';
COMMENT ON COLUMN events.start_date IS '이벤트 시작일';
COMMENT ON COLUMN events.end_date IS '이벤트 종료일';
COMMENT ON COLUMN events.status IS '이벤트 상태 (DRAFT/PUBLISHED/ENDED)';
COMMENT ON COLUMN events.selected_image_id IS '선택된 이미지 ID';
COMMENT ON COLUMN events.selected_image_url IS '선택된 이미지 URL';
COMMENT ON COLUMN events.created_at IS '생성일시';
COMMENT ON COLUMN events.updated_at IS '수정일시';
-- ============================================
-- 2. event_channels 테이블
-- ============================================
-- 이벤트 배포 채널 테이블
-- 이벤트별 배포 채널 정보 관리 (ElementCollection)
-- ============================================
CREATE TABLE IF NOT EXISTS event_channels (
event_id UUID NOT NULL,
channel VARCHAR(50) NOT NULL,
-- 제약조건
-- CONSTRAINT fk_event_channels_event FOREIGN KEY (event_id)
-- REFERENCES events(event_id) ON DELETE CASCADE,
CONSTRAINT pk_event_channels PRIMARY KEY (event_id, channel)
);
-- 인덱스
CREATE INDEX idx_event_channels_event_id ON event_channels(event_id);
-- 주석
COMMENT ON TABLE event_channels IS '이벤트 배포 채널 테이블';
COMMENT ON COLUMN event_channels.event_id IS '이벤트 ID (FK)';
COMMENT ON COLUMN event_channels.channel IS '배포 채널 (예: 카카오톡, 인스타그램 등)';
-- ============================================
-- 3. generated_images 테이블
-- ============================================
-- 생성된 이미지 테이블
-- 이벤트별로 생성된 이미지를 관리
-- ============================================
CREATE TABLE IF NOT EXISTS generated_images (
image_id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
event_id UUID NOT NULL,
image_url VARCHAR(500) NOT NULL,
style VARCHAR(50),
platform VARCHAR(50),
is_selected BOOLEAN NOT NULL DEFAULT FALSE,
created_at TIMESTAMP NOT NULL, -- Managed by JPA @CreatedDate
updated_at TIMESTAMP NOT NULL, -- Managed by JPA @LastModifiedDate
-- 제약조건
-- CONSTRAINT fk_generated_images_event FOREIGN KEY (event_id)
-- REFERENCES events(event_id) ON DELETE CASCADE
);
-- 인덱스
CREATE INDEX idx_generated_images_event_id ON generated_images(event_id);
CREATE INDEX idx_generated_images_is_selected ON generated_images(is_selected);
-- 복합 인덱스 (이벤트별 선택 이미지 조회 최적화)
CREATE INDEX idx_generated_images_event_selected ON generated_images(event_id, is_selected);
-- 주석
COMMENT ON TABLE generated_images IS '생성된 이미지 테이블';
COMMENT ON COLUMN generated_images.image_id IS '이미지 ID (PK)';
COMMENT ON COLUMN generated_images.event_id IS '이벤트 ID (FK)';
COMMENT ON COLUMN generated_images.image_url IS '이미지 URL';
COMMENT ON COLUMN generated_images.style IS '이미지 스타일';
COMMENT ON COLUMN generated_images.platform IS '플랫폼 (예: 인스타그램, 페이스북 등)';
COMMENT ON COLUMN generated_images.is_selected IS '선택 여부';
COMMENT ON COLUMN generated_images.created_at IS '생성일시';
COMMENT ON COLUMN generated_images.updated_at IS '수정일시';
-- ============================================
-- 4. ai_recommendations 테이블
-- ============================================
-- AI 추천 테이블
-- AI가 추천한 이벤트 기획안을 관리
-- ============================================
CREATE TABLE IF NOT EXISTS ai_recommendations (
recommendation_id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
event_id UUID NOT NULL,
event_name VARCHAR(200) NOT NULL,
description TEXT,
promotion_type VARCHAR(50),
target_audience VARCHAR(100),
is_selected BOOLEAN NOT NULL DEFAULT FALSE,
created_at TIMESTAMP NOT NULL, -- Managed by JPA @CreatedDate
updated_at TIMESTAMP NOT NULL, -- Managed by JPA @LastModifiedDate
-- 제약조건
-- CONSTRAINT fk_ai_recommendations_event FOREIGN KEY (event_id)
-- REFERENCES events(event_id) ON DELETE CASCADE
);
-- 인덱스
CREATE INDEX idx_ai_recommendations_event_id ON ai_recommendations(event_id);
CREATE INDEX idx_ai_recommendations_is_selected ON ai_recommendations(is_selected);
-- 복합 인덱스 (이벤트별 선택 추천 조회 최적화)
CREATE INDEX idx_ai_recommendations_event_selected ON ai_recommendations(event_id, is_selected);
-- 주석
COMMENT ON TABLE ai_recommendations IS 'AI 추천 이벤트 기획안 테이블';
COMMENT ON COLUMN ai_recommendations.recommendation_id IS '추천 ID (PK)';
COMMENT ON COLUMN ai_recommendations.event_id IS '이벤트 ID (FK)';
COMMENT ON COLUMN ai_recommendations.event_name IS '추천 이벤트명';
COMMENT ON COLUMN ai_recommendations.description IS '추천 이벤트 설명';
COMMENT ON COLUMN ai_recommendations.promotion_type IS '프로모션 유형';
COMMENT ON COLUMN ai_recommendations.target_audience IS '타겟 고객층';
COMMENT ON COLUMN ai_recommendations.is_selected IS '선택 여부';
COMMENT ON COLUMN ai_recommendations.created_at IS '생성일시';
COMMENT ON COLUMN ai_recommendations.updated_at IS '수정일시';
-- ============================================
-- 5. jobs 테이블
-- ============================================
-- 비동기 작업 테이블
-- AI 추천 생성, 이미지 생성 등의 비동기 작업 상태를 관리
-- ============================================
CREATE TABLE IF NOT EXISTS jobs (
job_id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
event_id UUID NOT NULL,
job_type VARCHAR(30) NOT NULL,
status VARCHAR(20) NOT NULL DEFAULT 'PENDING',
progress INT NOT NULL DEFAULT 0,
result_key VARCHAR(200),
error_message VARCHAR(500),
completed_at TIMESTAMP,
created_at TIMESTAMP NOT NULL, -- Managed by JPA @CreatedDate
updated_at TIMESTAMP NOT NULL, -- Managed by JPA @LastModifiedDate
-- 제약조건
-- CONSTRAINT fk_jobs_event FOREIGN KEY (event_id)
-- REFERENCES events(event_id) ON DELETE CASCADE,
CONSTRAINT chk_job_type CHECK (job_type IN ('AI_RECOMMENDATION', 'IMAGE_GENERATION')),
CONSTRAINT chk_job_status CHECK (status IN ('PENDING', 'PROCESSING', 'COMPLETED', 'FAILED')),
CONSTRAINT chk_job_progress CHECK (progress >= 0 AND progress <= 100)
);
-- 인덱스
CREATE INDEX idx_jobs_event_id ON jobs(event_id);
CREATE INDEX idx_jobs_status ON jobs(status);
CREATE INDEX idx_jobs_created_at ON jobs(created_at);
-- 복합 인덱스 (상태별 최신 작업 조회 최적화)
CREATE INDEX idx_jobs_status_created ON jobs(status, created_at DESC);
-- 주석
COMMENT ON TABLE jobs IS '비동기 작업 테이블';
COMMENT ON COLUMN jobs.job_id IS '작업 ID (PK)';
COMMENT ON COLUMN jobs.event_id IS '이벤트 ID (연관 이벤트)';
COMMENT ON COLUMN jobs.job_type IS '작업 유형 (AI_RECOMMENDATION/IMAGE_GENERATION)';
COMMENT ON COLUMN jobs.status IS '작업 상태 (PENDING/PROCESSING/COMPLETED/FAILED)';
COMMENT ON COLUMN jobs.progress IS '작업 진행률 (0-100)';
COMMENT ON COLUMN jobs.result_key IS '결과 키 (Redis 캐시 키 또는 리소스 식별자)';
COMMENT ON COLUMN jobs.error_message IS '오류 메시지 (실패 시)';
COMMENT ON COLUMN jobs.completed_at IS '완료일시';
COMMENT ON COLUMN jobs.created_at IS '생성일시';
COMMENT ON COLUMN jobs.updated_at IS '수정일시';
-- ============================================
-- Trigger for updated_at (자동 업데이트)
-- ============================================
-- NOTE: updated_at 필드는 JPA @LastModifiedDate 어노테이션으로 관리됩니다.
-- 따라서 PostgreSQL Trigger는 사용하지 않습니다.
-- JPA 환경에서는 애플리케이션 레벨에서 자동으로 updated_at이 갱신됩니다.
--
-- 만약 JPA 외부에서 직접 SQL로 데이터를 수정하는 경우,
-- 아래 Trigger를 활성화할 수 있습니다.
-- updated_at 자동 업데이트 함수 (비활성화)
-- CREATE OR REPLACE FUNCTION update_updated_at_column()
-- RETURNS TRIGGER AS $$
-- BEGIN
-- NEW.updated_at = CURRENT_TIMESTAMP;
-- RETURN NEW;
-- END;
-- $$ language 'plpgsql';
-- events 테이블 트리거 (비활성화)
-- CREATE TRIGGER update_events_updated_at BEFORE UPDATE ON events
-- FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
-- generated_images 테이블 트리거 (비활성화)
-- CREATE TRIGGER update_generated_images_updated_at BEFORE UPDATE ON generated_images
-- FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
-- ai_recommendations 테이블 트리거 (비활성화)
-- CREATE TRIGGER update_ai_recommendations_updated_at BEFORE UPDATE ON ai_recommendations
-- FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
-- jobs 테이블 트리거 (비활성화)
-- CREATE TRIGGER update_jobs_updated_at BEFORE UPDATE ON jobs
-- FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
-- ============================================
-- 샘플 데이터 (선택 사항)
-- ============================================
-- 개발/테스트 환경에서만 사용
-- 샘플 이벤트
-- INSERT INTO events (event_id, user_id, store_id, event_name, description, objective, start_date, end_date, status)
-- VALUES
-- (uuid_generate_v4(), uuid_generate_v4(), uuid_generate_v4(), '신규 고객 환영 이벤트', '첫 방문 고객 10% 할인', '신규 고객 유치', '2025-11-01', '2025-11-30', 'DRAFT');

213
develop/dev/content-service-api-mapping.md Normal file
View File

@ -0,0 +1,213 @@
# Content Service API 매핑표
**작성일**: 2025-10-24
**서비스**: content-service
**비교 대상**: ContentController.java ↔ content-service-api.yaml
## 1. API 매핑 테이블
| No | Controller 메서드 | HTTP 메서드 | 경로 | API 명세 operationId | 유저스토리 | 구현 상태 | 비고 |
|----|------------------|-------------|------|---------------------|-----------|-----------|------|
| 1 | generateImages | POST | /content/images/generate | generateImages | US-CT-001 | ✅ 구현완료 | 이미지 생성 요청, Job ID 즉시 반환 |
| 2 | getJobStatus | GET | /content/images/jobs/{jobId} | getImageGenerationStatus | US-CT-001 | ✅ 구현완료 | Job 상태 폴링용 |
| 3 | getContentByEventId | GET | /content/events/{eventDraftId} | getContentByEventId | US-CT-002 | ✅ 구현완료 | 이벤트 콘텐츠 조회 |
| 4 | getImages | GET | /content/events/{eventDraftId}/images | getImages | US-CT-003 | ✅ 구현완료 | 이미지 목록 조회 (스타일/플랫폼 필터링 지원) |
| 5 | getImageById | GET | /content/images/{imageId} | getImageById | US-CT-003 | ✅ 구현완료 | 특정 이미지 상세 조회 |
| 6 | deleteImage | DELETE | /content/images/{imageId} | deleteImage | US-CT-004 | ⚠️ TODO | 이미지 삭제 (미구현) |
| 7 | regenerateImage | POST | /content/images/{imageId}/regenerate | regenerateImage | US-CT-005 | ✅ 구현완료 | 이미지 재생성 요청 |
## 2. API 상세 비교
### 2.1. POST /content/images/generate (이미지 생성 요청)
**Controller 구현**:
```java
@PostMapping("/images/generate")
public ResponseEntity<JobInfo> generateImages(@RequestBody ContentCommand.GenerateImages command)
```
**API 명세**:
- operationId: `generateImages`
- Request Body: `GenerateImagesRequest`
- eventDraftId (Long, required)
- styles (List<String>, optional)
- platforms (List<String>, optional)
- Response: 202 Accepted → `JobResponse`
**매핑 상태**: ✅ 완전 일치
---
### 2.2. GET /content/images/jobs/{jobId} (Job 상태 조회)
**Controller 구현**:
```java
@GetMapping("/images/jobs/{jobId}")
public ResponseEntity<JobInfo> getJobStatus(@PathVariable String jobId)
```
**API 명세**:
- operationId: `getImageGenerationStatus`
- Path Parameter: `jobId` (String, required)
- Response: 200 OK → `JobResponse`
**매핑 상태**: ✅ 완전 일치
---
### 2.3. GET /content/events/{eventDraftId} (이벤트 콘텐츠 조회)
**Controller 구현**:
```java
@GetMapping("/events/{eventDraftId}")
public ResponseEntity<ContentInfo> getContentByEventId(@PathVariable Long eventDraftId)
```
**API 명세**:
- operationId: `getContentByEventId`
- Path Parameter: `eventDraftId` (Long, required)
- Response: 200 OK → `ContentResponse`
**매핑 상태**: ✅ 완전 일치
---
### 2.4. GET /content/events/{eventDraftId}/images (이미지 목록 조회)
**Controller 구현**:
```java
@GetMapping("/events/{eventDraftId}/images")
public ResponseEntity<List<ImageInfo>> getImages(
@PathVariable Long eventDraftId,
@RequestParam(required = false) String style,
@RequestParam(required = false) String platform)
```
**API 명세**:
- operationId: `getImages`
- Path Parameter: `eventDraftId` (Long, required)
- Query Parameters:
- style (String, optional)
- platform (String, optional)
- Response: 200 OK → Array of `ImageResponse`
**매핑 상태**: ✅ 완전 일치
---
### 2.5. GET /content/images/{imageId} (이미지 상세 조회)
**Controller 구현**:
```java
@GetMapping("/images/{imageId}")
public ResponseEntity<ImageInfo> getImageById(@PathVariable Long imageId)
```
**API 명세**:
- operationId: `getImageById`
- Path Parameter: `imageId` (Long, required)
- Response: 200 OK → `ImageResponse`
**매핑 상태**: ✅ 완전 일치
---
### 2.6. DELETE /content/images/{imageId} (이미지 삭제)
**Controller 구현**:
```java
@DeleteMapping("/images/{imageId}")
public ResponseEntity<Void> deleteImage(@PathVariable Long imageId) {
// TODO: 이미지 삭제 기능 구현 필요
throw new UnsupportedOperationException("이미지 삭제 기능은 아직 구현되지 않았습니다");
}
```
**API 명세**:
- operationId: `deleteImage`
- Path Parameter: `imageId` (Long, required)
- Response: 204 No Content
**매핑 상태**: ⚠️ **메서드 선언만 존재, 실제 로직 미구현**
**미구현 사유**:
- Phase 3 작업 범위는 JPA → Redis 전환
- 이미지 삭제 기능은 향후 구현 예정
- API 명세와 Controller 시그니처는 일치하나 내부 로직은 UnsupportedOperationException 발생
---
### 2.7. POST /content/images/{imageId}/regenerate (이미지 재생성)
**Controller 구현**:
```java
@PostMapping("/images/{imageId}/regenerate")
public ResponseEntity<JobInfo> regenerateImage(
@PathVariable Long imageId,
@RequestBody(required = false) ContentCommand.RegenerateImage requestBody)
```
**API 명세**:
- operationId: `regenerateImage`
- Path Parameter: `imageId` (Long, required)
- Request Body: `RegenerateImageRequest` (optional)
- style (String, optional)
- platform (String, optional)
- Response: 202 Accepted → `JobResponse`
**매핑 상태**: ✅ 완전 일치
---
## 3. 추가된 API 분석
**결과**: API 명세에 없는 추가 API는 **존재하지 않음**
- Controller에 구현된 모든 7개 엔드포인트는 API 명세서(content-service-api.yaml)에 정의되어 있음
- API 명세서의 모든 6개 경로(7개 operation)가 Controller에 구현되어 있음
## 4. 구현 상태 요약
### 4.1. 구현 완료 (6개)
1. ✅ POST /content/images/generate - 이미지 생성 요청
2. ✅ GET /content/images/jobs/{jobId} - Job 상태 조회
3. ✅ GET /content/events/{eventDraftId} - 이벤트 콘텐츠 조회
4. ✅ GET /content/events/{eventDraftId}/images - 이미지 목록 조회
5. ✅ GET /content/images/{imageId} - 이미지 상세 조회
6. ✅ POST /content/images/{imageId}/regenerate - 이미지 재생성
### 4.2. 미구현 (1개)
1. ⚠️ DELETE /content/images/{imageId} - 이미지 삭제
- **사유**: Phase 3은 JPA → Redis 전환 작업만 포함
- **향후 계획**: Phase 4 또는 추후 기능 개발 단계에서 구현 예정
- **현재 동작**: `UnsupportedOperationException` 발생
## 5. 검증 결과
### ✅ API 명세 준수도: 85.7% (6/7 구현)
- API 설계서와 Controller 구현이 **완전히 일치**함
- 모든 경로, HTTP 메서드, 파라미터 타입이 명세와 동일
- Response 타입도 명세의 스키마 정의와 일치
- 미구현 1건은 명시적으로 TODO 주석으로 표시되어 추후 구현 가능
### 권장 사항
1. **DELETE /content/images/{imageId} 구현 완료**
- ImageWriter 포트에 deleteImage 메서드 추가
- RedisGateway 및 MockRedisGateway에 구현
- Service 레이어 생성 (DeleteImageService)
- Controller의 TODO 제거
2. **통합 테스트 작성**
- 모든 구현된 API에 대한 통합 테스트 추가
- Mock 환경에서 전체 플로우 검증
3. **API 문서 동기화 유지**
- 향후 API 변경 시 명세서와 Controller 동시 업데이트
- OpenAPI Spec 자동 검증 도구 도입 고려
---
**문서 작성자**: Claude
**검증 완료**: 2025-10-24

785
develop/dev/content-service-modification-plan.md Normal file
View File

@ -0,0 +1,785 @@
# Content Service 아키텍처 수정 계획안
## 문서 정보
- **작성일**: 2025-10-24
- **작성자**: Backend Developer
- **대상 서비스**: Content Service
- **수정 사유**: 논리 아키텍처 설계 준수 (Redis 단독 저장소)
---
## 1. 현황 분석
### 1.1 논리 아키텍처 요구사항
**Content Service 핵심 책임** (논리 아키텍처 문서 기준):
- 3가지 스타일 SNS 이미지 자동 생성
- 플랫폼별 이미지 최적화
- 이미지 편집 기능
**데이터 저장 요구사항**:
```
데이터 저장:
- Redis: 이미지 생성 결과 (CDN URL, TTL 7일)
- CDN: 생성된 이미지 파일
```
**데이터 읽기 요구사항**:
```
데이터 읽기:
- Redis에서 AI Service가 저장한 이벤트 데이터 읽기
```
**캐시 구조** (논리 아키텍처 4.2절):
```
| 서비스 | 캐시 키 패턴 | 데이터 타입 | TTL | 예상 크기 |
|--------|-------------|-----------|-----|----------|
| Content | content:image:{이벤트ID}:{스타일} | String | 7일 | 0.2KB (URL) |
| AI | ai:event:{이벤트ID} | Hash | 24시간 | 10KB |
| AI/Content | job:{jobId} | Hash | 1시간 | 1KB |
```
### 1.2 현재 구현 문제점
**문제 1: RDB 사용**
- ❌ H2 In-Memory Database 사용 (Local)
- ❌ PostgreSQL 설정 (Production)
- ❌ Spring Data JPA 의존성 및 설정
**문제 2: JPA 엔티티 사용**
```java
// 현재 구현 (잘못됨)
@Entity
public class Content { ... }
@Entity
public class GeneratedImage { ... }
@Entity
public class Job { ... }
```
**문제 3: JPA Repository 사용**
```java
// 현재 구현 (잘못됨)
public interface ContentRepository extends JpaRepository<Content, Long> { ... }
public interface GeneratedImageRepository extends JpaRepository<GeneratedImage, Long> { ... }
public interface JobRepository extends JpaRepository<Job, String> { ... }
```
**문제 4: application-local.yml 설정**
```yaml
# 현재 구현 (잘못됨)
spring:
datasource:
url: jdbc:h2:mem:contentdb
username: sa
password:
driver-class-name: org.h2.Driver
jpa:
database-platform: org.hibernate.dialect.H2Dialect
hibernate:
ddl-auto: create-drop
```
### 1.3 올바른 아키텍처
```
[Client]
↓
[API Gateway]
↓
[Content Service]
├─→ [Redis] ← AI 이벤트 데이터 읽기
│ └─ content:image:{eventId}:{style} (이미지 URL 저장, TTL 7일)
│ └─ job:{jobId} (Job 상태, TTL 1시간)
│
└─→ [External Image API] (Stable Diffusion/DALL-E)
└─→ [Azure CDN] (이미지 파일 업로드)
```
**핵심 원칙**:
1. **Content Service는 Redis에만 데이터 저장**
2. **RDB (H2/PostgreSQL) 사용 안 함**
3. **JPA 사용 안 함**
4. **Redis는 캐시가 아닌 주 저장소로 사용**
---
## 2. 수정 계획
### 2.1 삭제 대상
#### 2.1.1 Entity 파일 (3개)
```
content-service/src/main/java/com/kt/event/content/biz/domain/
├─ Content.java ← 삭제
├─ GeneratedImage.java ← 삭제
└─ Job.java ← 삭제
```
#### 2.1.2 Repository 파일 (3개)
```
content-service/src/main/java/com/kt/event/content/biz/usecase/out/
├─ ContentRepository.java ← 삭제 (또는 이름만 남기고 인터페이스 변경)
├─ GeneratedImageRepository.java ← 삭제
└─ JobRepository.java ← 삭제
```
#### 2.1.3 JPA Adapter 파일 (있다면)
```
content-service/src/main/java/com/kt/event/content/infra/adapter/
└─ *JpaAdapter.java ← 모두 삭제
```
#### 2.1.4 설정 파일 수정
- `application-local.yml`: H2, JPA 설정 제거
- `application.yml`: PostgreSQL 설정 제거
- `build.gradle`: JPA, H2, PostgreSQL 의존성 제거
### 2.2 생성/수정 대상
#### 2.2.1 Redis 데이터 모델 (DTO)
**파일 위치**: `content-service/src/main/java/com/kt/event/content/biz/dto/`
**1) RedisImageData.java** (새로 생성)
```java
package com.kt.event.content.biz.dto;
import com.kt.event.content.biz.domain.ImageStyle;
import com.kt.event.content.biz.domain.Platform;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
/**
* Redis에 저장되는 이미지 데이터 구조
* Key: content:image:{eventDraftId}:{style}:{platform}
* Type: String (JSON)
* TTL: 7일
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class RedisImageData {
private Long id; // 이미지 고유 ID
private Long eventDraftId; // 이벤트 초안 ID
private ImageStyle style; // 이미지 스타일 (FANCY, SIMPLE, TRENDY)
private Platform platform; // 플랫폼 (INSTAGRAM, KAKAO, NAVER)
private String cdnUrl; // CDN 이미지 URL
private String prompt; // 이미지 생성 프롬프트
private Boolean selected; // 선택 여부
private LocalDateTime createdAt;
private LocalDateTime updatedAt;
}
```
**2) RedisJobData.java** (새로 생성)
```java
package com.kt.event.content.biz.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
/**
* Redis에 저장되는 Job 상태 정보
* Key: job:{jobId}
* Type: Hash
* TTL: 1시간
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class RedisJobData {
private String id; // Job ID (예: job-mock-7ada8bd3)
private Long eventDraftId; // 이벤트 초안 ID
private String jobType; // Job 타입 (image-generation, image-regeneration)
private String status; // 상태 (PENDING, IN_PROGRESS, COMPLETED, FAILED)
private Integer progress; // 진행률 (0-100)
private String resultMessage; // 결과 메시지
private String errorMessage; // 에러 메시지
private LocalDateTime createdAt;
private LocalDateTime updatedAt;
}
```
**3) RedisAIEventData.java** (새로 생성 - 읽기 전용)
```java
package com.kt.event.content.biz.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Map;
/**
* AI Service가 Redis에 저장한 이벤트 데이터 (읽기 전용)
* Key: ai:event:{eventDraftId}
* Type: Hash
* TTL: 24시간
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class RedisAIEventData {
private Long eventDraftId;
private String eventTitle;
private String eventDescription;
private String targetAudience;
private String eventObjective;
private Map<String, Object> additionalData; // AI가 생성한 추가 데이터
}
```
#### 2.2.2 Redis Gateway 확장
**파일**: `content-service/src/main/java/com/kt/event/content/infra/gateway/RedisGateway.java`
**추가 메서드**:
```java
// 이미지 CRUD
void saveImage(RedisImageData imageData, long ttlSeconds);
Optional<RedisImageData> getImage(Long eventDraftId, ImageStyle style, Platform platform);
List<RedisImageData> getImagesByEventId(Long eventDraftId);
void deleteImage(Long eventDraftId, ImageStyle style, Platform platform);
// Job 상태 관리
void saveJob(RedisJobData jobData, long ttlSeconds);
Optional<RedisJobData> getJob(String jobId);
void updateJobStatus(String jobId, String status, Integer progress);
void updateJobResult(String jobId, String resultMessage);
void updateJobError(String jobId, String errorMessage);
// AI 이벤트 데이터 읽기 (이미 구현됨 - getAIRecommendation)
// Optional<Map<String, Object>> getAIRecommendation(Long eventDraftId);
```
#### 2.2.3 MockRedisGateway 확장
**파일**: `content-service/src/main/java/com/kt/event/content/biz/service/mock/MockRedisGateway.java`
**추가 메서드**:
- 위의 RedisGateway와 동일한 메서드들을 In-Memory Map으로 구현
- Local/Test 환경에서 Redis 없이 테스트 가능
#### 2.2.4 Port Interface 수정
**파일**: `content-service/src/main/java/com/kt/event/content/biz/usecase/out/`
**1) ContentWriter.java 수정**
```java
package com.kt.event.content.biz.usecase.out;
import com.kt.event.content.biz.dto.RedisImageData;
import java.util.List;
/**
* Content 저장 Port (Redis 기반)
*/
public interface ContentWriter {
// 이미지 저장 (Redis)
void saveImage(RedisImageData imageData, long ttlSeconds);
// 이미지 삭제 (Redis)
void deleteImage(Long eventDraftId, String style, String platform);
// 여러 이미지 저장 (Redis)
void saveImages(Long eventDraftId, List<RedisImageData> images, long ttlSeconds);
}
```
**2) ContentReader.java 수정**
```java
package com.kt.event.content.biz.usecase.out;
import com.kt.event.content.biz.dto.RedisImageData;
import java.util.List;
import java.util.Optional;
/**
* Content 조회 Port (Redis 기반)
*/
public interface ContentReader {
// 특정 이미지 조회 (Redis)
Optional<RedisImageData> getImage(Long eventDraftId, String style, String platform);
// 이벤트의 모든 이미지 조회 (Redis)
List<RedisImageData> getImagesByEventId(Long eventDraftId);
}
```
**3) JobWriter.java 수정**
```java
package com.kt.event.content.biz.usecase.out;
import com.kt.event.content.biz.dto.RedisJobData;
/**
* Job 상태 저장 Port (Redis 기반)
*/
public interface JobWriter {
// Job 생성 (Redis)
void saveJob(RedisJobData jobData, long ttlSeconds);
// Job 상태 업데이트 (Redis)
void updateJobStatus(String jobId, String status, Integer progress);
// Job 결과 업데이트 (Redis)
void updateJobResult(String jobId, String resultMessage);
// Job 에러 업데이트 (Redis)
void updateJobError(String jobId, String errorMessage);
}
```
**4) JobReader.java 수정**
```java
package com.kt.event.content.biz.usecase.out;
import com.kt.event.content.biz.dto.RedisJobData;
import java.util.Optional;
/**
* Job 상태 조회 Port (Redis 기반)
*/
public interface JobReader {
// Job 조회 (Redis)
Optional<RedisJobData> getJob(String jobId);
}
```
#### 2.2.5 Service Layer 수정
**파일**: `content-service/src/main/java/com/kt/event/content/biz/service/`
**주요 변경사항**:
1. JPA Repository 의존성 제거
2. RedisGateway 사용으로 변경
3. 도메인 Entity → DTO 변환 로직 추가
**예시: ContentServiceImpl.java**
```java
@Service
@RequiredArgsConstructor
public class ContentServiceImpl implements ContentService {
// ❌ 삭제: private final ContentRepository contentRepository;
// ✅ 추가: private final RedisGateway redisGateway;
private final ContentWriter contentWriter; // Redis 기반
private final ContentReader contentReader; // Redis 기반
@Override
public List<ImageInfo> getImagesByEventId(Long eventDraftId) {
List<RedisImageData> redisData = contentReader.getImagesByEventId(eventDraftId);
return redisData.stream()
.map(this::toImageInfo)
.collect(Collectors.toList());
}
private ImageInfo toImageInfo(RedisImageData data) {
return ImageInfo.builder()
.id(data.getId())
.eventDraftId(data.getEventDraftId())
.style(data.getStyle())
.platform(data.getPlatform())
.cdnUrl(data.getCdnUrl())
.prompt(data.getPrompt())
.selected(data.getSelected())
.createdAt(data.getCreatedAt())
.updatedAt(data.getUpdatedAt())
.build();
}
}
```
#### 2.2.6 설정 파일 수정
**1) application-local.yml 수정 후**
```yaml
spring:
# ❌ 삭제: datasource, h2, jpa 설정
data:
redis:
repositories:
enabled: false
host: localhost
port: 6379
autoconfigure:
exclude:
- org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration
- org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration
server:
port: 8084
logging:
level:
com.kt.event: DEBUG
```
**2) build.gradle 수정**
```gradle
dependencies {
// ❌ 삭제
// implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
// runtimeOnly 'com.h2database:h2'
// runtimeOnly 'org.postgresql:postgresql'
// ✅ 유지
implementation 'org.springframework.boot:spring-boot-starter-data-redis'
implementation 'io.lettuce:lettuce-core'
// 기타 의존성 유지
implementation 'org.springframework.boot:spring-boot-starter-web'
implementation 'org.springframework.boot:spring-boot-starter-validation'
compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'
}
```
---
## 3. Redis Key 구조 설계
### 3.1 이미지 데이터
**Key Pattern**: `content:image:{eventDraftId}:{style}:{platform}`
**예시**:
```
content:image:1:FANCY:INSTAGRAM
content:image:1:SIMPLE:KAKAO
```
**Data Type**: String (JSON)
**Value 예시**:
```json
{
"id": 1,
"eventDraftId": 1,
"style": "FANCY",
"platform": "INSTAGRAM",
"cdnUrl": "https://cdn.azure.com/images/1/fancy_instagram_7ada8bd3.png",
"prompt": "Mock prompt for FANCY style on INSTAGRAM platform",
"selected": true,
"createdAt": "2025-10-23T21:52:57.524759",
"updatedAt": "2025-10-23T21:52:57.524759"
}
```
**TTL**: 7일 (604800초)
### 3.2 Job 상태
**Key Pattern**: `job:{jobId}`
**예시**:
```
job:job-mock-7ada8bd3
job:job-regen-df2bb3a3
```
**Data Type**: Hash
**Fields**:
```
id: "job-mock-7ada8bd3"
eventDraftId: "1"
jobType: "image-generation"
status: "COMPLETED"
progress: "100"
resultMessage: "4개의 이미지가 성공적으로 생성되었습니다."
errorMessage: null
createdAt: "2025-10-23T21:52:57.511438"
updatedAt: "2025-10-23T21:52:58.571923"
```
**TTL**: 1시간 (3600초)
### 3.3 AI 이벤트 데이터 (읽기 전용)
**Key Pattern**: `ai:event:{eventDraftId}`
**예시**:
```
ai:event:1
```
**Data Type**: Hash
**Fields** (AI Service가 저장):
```
eventDraftId: "1"
eventTitle: "Mock 이벤트 제목 1"
eventDescription: "Mock 이벤트 설명입니다."
targetAudience: "20-30대 여성"
eventObjective: "신규 고객 유치"
```
**TTL**: 24시간 (86400초)
---
## 4. 마이그레이션 전략
### 4.1 단계별 마이그레이션
**Phase 1: Redis 구현 추가** (기존 JPA 유지)
1. RedisImageData, RedisJobData DTO 생성
2. RedisGateway에 이미지/Job CRUD 메서드 추가
3. MockRedisGateway 확장
4. 단위 테스트 작성 및 검증
**Phase 2: Service Layer 전환**
1. 새로운 Port Interface 생성 (Redis 기반)
2. Service에서 Redis Port 사용하도록 수정
3. 통합 테스트로 기능 검증
**Phase 3: JPA 제거**
1. Entity, Repository, Adapter 파일 삭제
2. JPA 설정 및 의존성 제거
3. 전체 테스트 재실행
**Phase 4: 문서화 및 배포**
1. API 테스트 결과서 업데이트
2. 수정 내역 commit & push
3. Production 배포
### 4.2 롤백 전략
각 Phase마다 별도 branch 생성:
```
feature/content-redis-phase1
feature/content-redis-phase2
feature/content-redis-phase3
```
문제 발생 시 이전 Phase branch로 롤백 가능
---
## 5. 테스트 계획
### 5.1 단위 테스트
**RedisGatewayTest.java**:
```java
@Test
void saveAndGetImage_성공() {
// Given
RedisImageData imageData = RedisImageData.builder()
.id(1L)
.eventDraftId(1L)
.style(ImageStyle.FANCY)
.platform(Platform.INSTAGRAM)
.cdnUrl("https://cdn.azure.com/test.png")
.build();
// When
redisGateway.saveImage(imageData, 604800);
Optional<RedisImageData> result = redisGateway.getImage(1L, ImageStyle.FANCY, Platform.INSTAGRAM);
// Then
assertThat(result).isPresent();
assertThat(result.get().getCdnUrl()).isEqualTo("https://cdn.azure.com/test.png");
}
```
### 5.2 통합 테스트
**ContentServiceIntegrationTest.java**:
```java
@SpringBootTest
@Testcontainers
class ContentServiceIntegrationTest {
@Container
static GenericContainer<?> redis = new GenericContainer<>("redis:7.2")
.withExposedPorts(6379);
@Test
void 이미지_생성_및_조회_전체_플로우() {
// 1. AI 이벤트 데이터 Redis 저장 (Mock)
// 2. 이미지 생성 Job 요청
// 3. Job 상태 폴링
// 4. 이미지 조회
// 5. 검증
}
}
```
### 5.3 API 테스트
기존 test-backend.md의 7개 API 테스트 재실행:
1. POST /content/images/generate
2. GET /content/images/jobs/{jobId}
3. GET /content/events/{eventDraftId}
4. GET /content/events/{eventDraftId}/images
5. GET /content/images/{imageId}
6. POST /content/images/{imageId}/regenerate
7. DELETE /content/images/{imageId}
**예상 결과**: 모든 API 정상 동작 (Redis 기반)
---
## 6. 성능 및 용량 산정
### 6.1 Redis 메모리 사용량
**이미지 데이터**:
- 1개 이미지: 약 0.5KB (JSON)
- 1개 이벤트당 이미지: 최대 9개 (3 style × 3 platform)
- 1개 이벤트당 용량: 4.5KB
**Job 데이터**:
- 1개 Job: 약 1KB (Hash)
- 동시 처리 Job: 최대 50개
- Job 총 용량: 50KB
**예상 총 메모리**:
- 동시 이벤트 50개 × 4.5KB = 225KB
- Job 50KB
- 버퍼 (20%): 55KB
- **총 메모리**: 약 330KB (여유 충분)
### 6.2 TTL 전략
| 데이터 타입 | TTL | 이유 |
|------------|-----|------|
| 이미지 URL | 7일 (604800초) | 이벤트 기간 동안 재사용 |
| Job 상태 | 1시간 (3600초) | 완료 후 빠른 정리 |
| AI 이벤트 데이터 | 24시간 (86400초) | AI Service 관리 |
---
## 7. 체크리스트
### 7.1 구현 체크리스트
- [ ] RedisImageData DTO 생성
- [ ] RedisJobData DTO 생성
- [ ] RedisAIEventData DTO 생성
- [ ] RedisGateway 이미지 CRUD 메서드 추가
- [ ] RedisGateway Job 상태 관리 메서드 추가
- [ ] MockRedisGateway 확장
- [ ] Port Interface 수정 (ContentWriter, ContentReader, JobWriter, JobReader)
- [ ] Service Layer JPA → Redis 전환
- [ ] JPA Entity 파일 삭제
- [ ] JPA Repository 파일 삭제
- [ ] application-local.yml H2/JPA 설정 제거
- [ ] build.gradle JPA/H2/PostgreSQL 의존성 제거
- [ ] 단위 테스트 작성
- [ ] 통합 테스트 작성
- [ ] API 테스트 재실행 (7개 엔드포인트)
### 7.2 검증 체크리스트
- [ ] Redis 연결 정상 동작 확인
- [ ] 이미지 저장/조회 정상 동작
- [ ] Job 상태 업데이트 정상 동작
- [ ] TTL 자동 만료 확인
- [ ] 모든 API 테스트 통과 (100%)
- [ ] 서버 기동 시 에러 없음
- [ ] JPA 관련 로그 완전히 사라짐
### 7.3 문서화 체크리스트
- [ ] 수정 계획안 작성 완료 (이 문서)
- [ ] API 테스트 결과서 업데이트
- [ ] Redis Key 구조 문서화
- [ ] 개발 가이드 업데이트
---
## 8. 예상 이슈 및 대응 방안
### 8.1 Redis 장애 시 대응
**문제**: Redis 서버 다운 시 서비스 중단
**대응 방안**:
- **Local/Test**: MockRedisGateway로 대체 (자동)
- **Production**: Redis Sentinel을 통한 자동 Failover
- **Circuit Breaker**: Redis 실패 시 임시 In-Memory 캐시 사용
### 8.2 TTL 만료 후 데이터 복구
**문제**: 이미지 URL이 TTL 만료로 삭제됨
**대응 방안**:
- **Event Service가 최종 승인 시**: Redis → Event DB 영구 저장 (논리 아키텍처 설계)
- **TTL 연장 API**: 필요 시 TTL 연장 가능한 API 제공
- **이미지 재생성 API**: 이미 구현되어 있음 (POST /content/images/{id}/regenerate)
### 8.3 ID 생성 전략
**문제**: RDB auto-increment 없이 ID 생성 필요
**대응 방안**:
- **이미지 ID**: Redis INCR 명령으로 순차 ID 생성
```
INCR content:image:id:counter
```
- **Job ID**: UUID 기반 (기존 방식 유지)
```java
String jobId = "job-mock-" + UUID.randomUUID().toString().substring(0, 8);
```
---
## 9. 결론
### 9.1 수정 필요성
Content Service는 논리 아키텍처 설계에 따라 **Redis를 주 저장소로 사용**해야 하며, RDB (H2/PostgreSQL)는 사용하지 않아야 합니다. 현재 구현은 설계와 불일치하므로 전면 수정이 필요합니다.
### 9.2 기대 효과
**아키텍처 준수**:
- ✅ 논리 아키텍처 설계 100% 준수
- ✅ Redis 단독 저장소 전략
- ✅ 불필요한 RDB 의존성 제거
**성능 개선**:
- ✅ 메모리 기반 Redis로 응답 속도 향상
- ✅ TTL 자동 만료로 메모리 관리 최적화
**운영 간소화**:
- ✅ Content Service DB 운영 불필요
- ✅ 백업/복구 절차 간소화
### 9.3 다음 단계
1. **승인 요청**: 이 수정 계획안 검토 및 승인
2. **Phase 1 착수**: Redis 구현 추가 (기존 코드 유지)
3. **단계별 진행**: Phase 1 → 2 → 3 순차 진행
4. **테스트 및 배포**: 각 Phase마다 검증 후 다음 단계 진행
---
**문서 버전**: 1.0
**최종 수정일**: 2025-10-24
**작성자**: Backend Developer

292
develop/dev/event-api-mapping.md Normal file
View File

@ -0,0 +1,292 @@
# Event Service API 매핑표
## 문서 정보
- **작성일**: 2025-10-24
- **버전**: 1.0
- **작성자**: Event Service Team
- **관련 문서**:
- [API 설계서](../../design/backend/api/API-설계서.md)
- [Event Service OpenAPI](../../design/backend/api/event-service-api.yaml)
---
## 1. 매핑 현황 요약
### 구현 현황
- **설계된 API**: 14개
- **구현된 API**: 7개 (50.0%)
- **미구현 API**: 7개 (50.0%)
### 구현률 세부
| 카테고리 | 설계 | 구현 | 미구현 | 구현률 |
|---------|------|------|--------|--------|
| Dashboard & Event List | 2 | 2 | 0 | 100% |
| Event Creation Flow | 8 | 1 | 7 | 12.5% |
| Event Management | 3 | 3 | 0 | 100% |
| Job Status | 1 | 1 | 0 | 100% |
---
## 2. 상세 매핑표
### 2.1 Dashboard & Event List (구현률 100%)
| 설계서 API | Controller | 메서드 | 경로 | 구현 여부 | 비고 |
|-----------|-----------|--------|------|----------|------|
| 이벤트 목록 조회 | EventController | GET | /api/events | ✅ 구현 | EventController:84 |
| 이벤트 상세 조회 | EventController | GET | /api/events/{eventId} | ✅ 구현 | EventController:130 |
---
### 2.2 Event Creation Flow (구현률 12.5%)
#### Step 1: 이벤트 목적 선택
| 설계서 API | Controller | 메서드 | 경로 | 구현 여부 | 비고 |
|-----------|-----------|--------|------|----------|------|
| 이벤트 목적 선택 | EventController | POST | /api/events/objectives | ✅ 구현 | EventController:52 |
#### Step 2: AI 추천 (미구현)
| 설계서 API | Controller | 메서드 | 경로 | 구현 여부 | 미구현 이유 |
|-----------|-----------|--------|------|----------|-----------|
| AI 추천 요청 | - | POST | /api/events/{eventId}/ai-recommendations | ❌ 미구현 | AI Service 연동 필요 |
| AI 추천 선택 | - | PUT | /api/events/{eventId}/recommendations | ❌ 미구현 | AI Service 연동 필요 |
**미구현 상세 이유**:
- Kafka Topic `ai-event-generation-job` 발행 로직 필요
- AI Service와의 연동이 선행되어야 함
- Redis에서 AI 추천 결과를 읽어오는 로직 필요
- 현재 단계에서는 이벤트 생명주기 관리에 집중
#### Step 3: 이미지 생성 (미구현)
| 설계서 API | Controller | 메서드 | 경로 | 구현 여부 | 미구현 이유 |
|-----------|-----------|--------|------|----------|-----------|
| 이미지 생성 요청 | - | POST | /api/events/{eventId}/images | ❌ 미구현 | Content Service 연동 필요 |
| 이미지 선택 | - | PUT | /api/events/{eventId}/images/{imageId}/select | ❌ 미구현 | Content Service 연동 필요 |
| 이미지 편집 | - | PUT | /api/events/{eventId}/images/{imageId}/edit | ❌ 미구현 | Content Service 연동 필요 |
**미구현 상세 이유**:
- Kafka Topic `image-generation-job` 발행 로직 필요
- Content Service와의 연동이 선행되어야 함
- Redis에서 생성된 이미지 URL을 읽어오는 로직 필요
- 이미지 편집은 Content Service의 이미지 재생성 API와 연동 필요
#### Step 4: 배포 채널 선택 (미구현)
| 설계서 API | Controller | 메서드 | 경로 | 구현 여부 | 미구현 이유 |
|-----------|-----------|--------|------|----------|-----------|
| 배포 채널 선택 | - | PUT | /api/events/{eventId}/channels | ❌ 미구현 | Distribution Service 연동 필요 |
**미구현 상세 이유**:
- Distribution Service의 채널 목록 검증 로직 필요
- Event 엔티티의 channels 필드 업데이트 로직은 구현 가능하나, 채널별 검증은 Distribution Service 개발 후 추가 예정
#### Step 5: 최종 승인 및 배포
| 설계서 API | Controller | 메서드 | 경로 | 구현 여부 | 비고 |
|-----------|-----------|--------|------|----------|------|
| 최종 승인 및 배포 | EventController | POST | /api/events/{eventId}/publish | ✅ 구현 | EventController:172 |
**구현 내용**:
- 이벤트 상태를 DRAFT → PUBLISHED로 변경
- Distribution Service 동기 호출은 추후 추가 예정
- 현재는 상태 변경만 처리
---
### 2.3 Event Management (구현률 100%)
| 설계서 API | Controller | 메서드 | 경로 | 구현 여부 | 비고 |
|-----------|-----------|--------|------|----------|------|
| 이벤트 수정 | - | PUT | /api/events/{eventId} | ❌ 미구현 | 이유는 아래 참조 |
| 이벤트 삭제 | EventController | DELETE | /api/events/{eventId} | ✅ 구현 | EventController:151 |
| 이벤트 조기 종료 | EventController | POST | /api/events/{eventId}/end | ✅ 구현 | EventController:193 |
**이벤트 수정 API 미구현 이유**:
- 이벤트 수정은 여러 단계의 데이터를 수정하는 복잡한 로직
- AI 추천 재선택, 이미지 재생성 등 다른 서비스와의 연동이 필요
- 우선순위: 신규 이벤트 생성 플로우 완성 후 구현 예정
- 현재는 DRAFT 상태에서만 삭제 가능하므로 수정 대신 삭제 후 재생성 가능
---
### 2.4 Job Status (구현률 100%)
| 설계서 API | Controller | 메서드 | 경로 | 구현 여부 | 비고 |
|-----------|-----------|--------|------|----------|------|
| Job 상태 폴링 | JobController | GET | /api/jobs/{jobId} | ✅ 구현 | JobController:42 |
---
## 3. 구현된 API 상세
### 3.1 EventController (6개 API)
#### 1. POST /api/events/objectives
- **설명**: 이벤트 생성의 첫 단계로 목적을 선택
- **유저스토리**: UFR-EVENT-020
- **요청**: SelectObjectiveRequest (objective)
- **응답**: EventCreatedResponse (eventId, status, objective, createdAt)
- **비즈니스 로직**:
- Long userId/storeId를 UUID로 변환하여 Event 엔티티 생성
- 초기 상태는 DRAFT
- EventService.createEvent() 호출
#### 2. GET /api/events
- **설명**: 사용자의 이벤트 목록 조회 (페이징, 필터링, 정렬)
- **유저스토리**: UFR-EVENT-010, UFR-EVENT-070
- **요청 파라미터**:
- status (EventStatus, 선택)
- search (String, 선택)
- objective (String, 선택)
- page, size, sort, order (페이징/정렬)
- **응답**: PageResponse<EventDetailResponse>
- **비즈니스 로직**:
- Long userId를 UUID로 변환
- Repository에서 필터링 및 페이징 처리
- EventService.getEvents() 호출
#### 3. GET /api/events/{eventId}
- **설명**: 특정 이벤트의 상세 정보 조회
- **유저스토리**: UFR-EVENT-060
- **요청**: eventId (UUID)
- **응답**: EventDetailResponse (이벤트 정보 + 생성된 이미지 + AI 추천)
- **비즈니스 로직**:
- Long userId를 UUID로 변환
- 사용자 소유 이벤트만 조회 가능 (보안)
- EventService.getEvent() 호출
#### 4. DELETE /api/events/{eventId}
- **설명**: 이벤트 삭제 (DRAFT 상태만 가능)
- **유저스토리**: UFR-EVENT-070
- **요청**: eventId (UUID)
- **응답**: ApiResponse<Void>
- **비즈니스 로직**:
- DRAFT 상태만 삭제 가능 검증 (Event.isDeletable())
- 다른 상태(PUBLISHED, ENDED)는 삭제 불가
- EventService.deleteEvent() 호출
#### 5. POST /api/events/{eventId}/publish
- **설명**: 이벤트 배포 (DRAFT → PUBLISHED)
- **유저스토리**: UFR-EVENT-050
- **요청**: eventId (UUID)
- **응답**: ApiResponse<Void>
- **비즈니스 로직**:
- Event.publish() 메서드로 상태 전환
- Distribution Service 호출은 추후 추가 예정
- EventService.publishEvent() 호출
#### 6. POST /api/events/{eventId}/end
- **설명**: 이벤트 조기 종료 (PUBLISHED → ENDED)
- **유저스토리**: UFR-EVENT-060
- **요청**: eventId (UUID)
- **응답**: ApiResponse<Void>
- **비즈니스 로직**:
- Event.end() 메서드로 상태 전환
- PUBLISHED 상태만 종료 가능
- EventService.endEvent() 호출
---
### 3.2 JobController (1개 API)
#### 1. GET /api/jobs/{jobId}
- **설명**: 비동기 작업의 상태를 조회 (폴링 방식)
- **유저스토리**: UFR-EVENT-030, UFR-CONT-010
- **요청**: jobId (UUID)
- **응답**: JobStatusResponse (jobId, jobType, status, progress, resultKey, errorMessage)
- **비즈니스 로직**:
- Job 엔티티 조회
- 상태: PENDING, PROCESSING, COMPLETED, FAILED
- JobService.getJobStatus() 호출
---
## 4. 미구현 API 개발 계획
### 4.1 우선순위 1 (AI Service 연동)
- **POST /api/events/{eventId}/ai-recommendations** - AI 추천 요청
- **PUT /api/events/{eventId}/recommendations** - AI 추천 선택
**개발 선행 조건**:
1. AI Service 개발 완료
2. Kafka Topic `ai-event-generation-job` 설정
3. Redis 캐시 연동 구현
---
### 4.2 우선순위 2 (Content Service 연동)
- **POST /api/events/{eventId}/images** - 이미지 생성 요청
- **PUT /api/events/{eventId}/images/{imageId}/select** - 이미지 선택
- **PUT /api/events/{eventId}/images/{imageId}/edit** - 이미지 편집
**개발 선행 조건**:
1. Content Service 개발 완료
2. Kafka Topic `image-generation-job` 설정
3. Redis 캐시 연동 구현
4. CDN (Azure Blob Storage) 연동
---
### 4.3 우선순위 3 (Distribution Service 연동)
- **PUT /api/events/{eventId}/channels** - 배포 채널 선택
**개발 선행 조건**:
1. Distribution Service 개발 완료
2. 채널별 검증 로직 구현
3. POST /api/events/{eventId}/publish API에 Distribution Service 동기 호출 추가
---
### 4.4 우선순위 4 (이벤트 수정)
- **PUT /api/events/{eventId}** - 이벤트 수정
**개발 선행 조건**:
1. 우선순위 1~3 API 모두 구현 완료
2. 이벤트 수정 범위 정의 (이름/설명/날짜만 수정 vs 전체 재생성)
3. 각 단계별 수정 로직 설계
---
## 5. 추가 구현된 API (설계서에 없음)
현재 추가 구현된 API는 없습니다. 모든 구현은 설계서를 기준으로 진행되었습니다.
---
## 6. 다음 단계
### 6.1 즉시 가능한 작업
1. **서버 시작 테스트**:
- PostgreSQL 연결 확인
- Swagger UI 접근 테스트 (http://localhost:8081/swagger-ui.html)
2. **구현된 API 테스트**:
- POST /api/events/objectives
- GET /api/events
- GET /api/events/{eventId}
- DELETE /api/events/{eventId}
- POST /api/events/{eventId}/publish
- POST /api/events/{eventId}/end
- GET /api/jobs/{jobId}
### 6.2 후속 개발 필요
1. AI Service 개발 완료 → AI 추천 API 구현
2. Content Service 개발 완료 → 이미지 관련 API 구현
3. Distribution Service 개발 완료 → 배포 채널 선택 API 구현
4. 전체 서비스 연동 → 이벤트 수정 API 구현
---
## 부록
### A. 개발 우선순위 결정 근거
**현재 구현 범위 선정 이유**:
1. **핵심 생명주기 먼저**: 이벤트 생성, 조회, 삭제, 상태 변경
2. **서비스 독립성**: 다른 서비스 없이도 Event Service 단독 테스트 가능
3. **점진적 통합**: 각 서비스 개발 완료 시점에 순차적 통합
4. **리스크 최소화**: 복잡한 서비스 간 연동은 각 서비스 안정화 후 진행
---
**문서 버전**: 1.0
**최종 수정일**: 2025-10-24
**작성자**: Event Service Team

206
develop/dev/test-backend-participation.md Normal file
View File

@ -0,0 +1,206 @@
# Participation Service 백엔드 테스트 결과
## 테스트 정보
- **테스트 일시**: 2025-10-27
- **서비스**: participation-service
- **포트**: 8084
- **테스트 수행자**: AI Assistant
## 1. 실행 프로파일 작성
### 1.1 작성된 파일
1. **`.run/ParticipationServiceApplication.run.xml`**
- IntelliJ Gradle 실행 프로파일
- 16개 환경 변수 설정
2. **`participation-service/.run/participation-service.run.xml`**
- 서비스별 실행 프로파일
- 동일한 환경 변수 구성
### 1.2 환경 변수 구성
```yaml
# 서버 설정
SERVER_PORT: 8084
# 데이터베이스 설정
DB_HOST: 4.230.72.147
DB_PORT: 5432
DB_NAME: participationdb
DB_USERNAME: eventuser
DB_PASSWORD: Hi5Jessica!
# JPA 설정
DDL_AUTO: validate # ✅ update → validate로 수정
SHOW_SQL: true
# Redis 설정 (추가됨)
REDIS_HOST: 20.214.210.71
REDIS_PORT: 6379
REDIS_PASSWORD: Hi5Jessica!
# Kafka 설정
KAFKA_BOOTSTRAP_SERVERS: 20.249.182.13:9095,4.217.131.59:9095
# JWT 설정
JWT_SECRET: kt-event-marketing-secret-key-for-development-only-change-in-production
JWT_EXPIRATION: 86400000
# 로깅 설정
LOG_LEVEL: INFO
LOG_FILE: logs/participation-service.log
```
## 2. 발생한 오류 및 수정 내역
### 2.1 오류 1: PostgreSQL 인덱스 중복
**증상**:
```
Caused by: org.postgresql.util.PSQLException: ERROR: relation "idx_event_id" already exists
```
**원인**:
- Hibernate DDL 모드가 `update`로 설정되어 이미 존재하는 인덱스를 생성하려고 시도
**수정**:
- `application.yml`: `ddl-auto: ${DDL_AUTO:validate}`로 변경
- 실행 프로파일: `DDL_AUTO=validate`로 설정
- **파일**:
- `participation-service/src/main/resources/application.yml` (21번 라인)
- `.run/ParticipationServiceApplication.run.xml` (17번 라인)
- `participation-service/.run/participation-service.run.xml` (17번 라인)
### 2.2 오류 2: Redis 연결 실패
**증상**:
```
Caused by: io.lettuce.core.RedisConnectionException: Unable to connect to localhost/<unresolved>:6379
```
**원인**:
- Redis 설정이 `application.yml`에 완전히 누락되어 기본값(localhost:6379)으로 연결 시도
**수정**:
- `application.yml`에 Redis 설정 섹션 추가:
```yaml
spring:
data:
redis:
host: ${REDIS_HOST:20.214.210.71}
port: ${REDIS_PORT:6379}
password: ${REDIS_PASSWORD:Hi5Jessica!}
timeout: 3000ms
lettuce:
pool:
max-active: 8
max-idle: 8
min-idle: 2
max-wait: -1ms
```
- 실행 프로파일에 Redis 환경 변수 3개 추가
- **파일**:
- `participation-service/src/main/resources/application.yml` (29-41번 라인)
- `.run/ParticipationServiceApplication.run.xml` (20-22번 라인)
- `participation-service/.run/participation-service.run.xml` (20-22번 라인)
### 2.3 오류 3: PropertyReferenceException (해결됨)
**증상**:
```
org.springframework.data.mapping.PropertyReferenceException: No property 'string' found for type 'Participant'
```
**상태**:
- 위의 설정 수정 후 더 이상 발생하지 않음
- 현재 API 호출 시 정상 동작 확인
## 3. 테스트 결과
### 3.1 서비스 상태 확인
```bash
$ curl -s "http://localhost:8084/actuator/health"
{
"status": "UP"
}
```
✅ **결과**: 정상 (UP)
### 3.2 API 엔드포인트 테스트
#### 참여자 목록 조회
```bash
$ curl "http://localhost:8084/events/3/participants?storeVisited=true"
{
"success": true,
"data": {
"content": [],
"page": 0,
"size": 20,
"totalElements": 0,
"totalPages": 0,
"first": true,
"last": true
},
"timestamp": "2025-10-27T10:30:28.622134"
}
```
✅ **결과**: HTTP 200, 정상 응답 (데이터 없음은 정상)
### 3.3 인프라 연결 상태
| 구성요소 | 상태 | 접속 정보 |
|---------|------|-----------|
| PostgreSQL | ✅ 정상 | 4.230.72.147:5432/participationdb |
| Redis | ✅ 정상 | 20.214.210.71:6379 |
| Kafka | ✅ 정상 | 20.249.182.13:9095,4.217.131.59:9095 |
## 4. 수정된 파일 목록
1. **`participation-service/src/main/resources/application.yml`**
- JPA DDL 모드: `update` → `validate`
- Redis 설정 전체 추가
2. **`.run/ParticipationServiceApplication.run.xml`**
- DDL_AUTO 환경 변수: `update` → `validate`
- Redis 환경 변수 3개 추가 (REDIS_HOST, REDIS_PORT, REDIS_PASSWORD)
3. **`participation-service/.run/participation-service.run.xml`**
- DDL_AUTO 환경 변수: `update` → `validate`
- Redis 환경 변수 3개 추가
## 5. 결론
### 5.1 테스트 성공 여부
✅ **성공**: 모든 오류가 수정되었고 서비스가 정상적으로 작동함
### 5.2 주요 성과
1. ✅ IntelliJ 실행 프로파일 작성 완료
2. ✅ PostgreSQL 인덱스 중복 오류 해결
3. ✅ Redis 연결 설정 완료
4. ✅ PropertyReferenceException 오류 해결
5. ✅ Health 체크 통과 (모든 인프라 연결 정상)
6. ✅ API 엔드포인트 정상 동작 확인
### 5.3 권장사항
1. **프로덕션 환경**:
- `DDL_AUTO`를 `none`으로 설정하고 Flyway/Liquibase 같은 마이그레이션 도구 사용 권장
- JWT_SECRET을 안전한 값으로 변경 필수
2. **로깅**:
- 프로덕션에서는 `SHOW_SQL=false`로 설정 권장
- LOG_LEVEL을 `WARN` 또는 `ERROR`로 조정
3. **테스트 데이터**:
- 현재 참여자 데이터가 없으므로 테스트 데이터 추가 고려
## 6. 다음 단계
1. **API 통합 테스트**:
- 참여자 등록 API 테스트
- 참여자 조회 API 테스트
- 당첨자 추첨 API 테스트
2. **성능 테스트**:
- 대량 참여자 등록 시나리오
- 동시 접속 테스트
3. **E2E 테스트**:
- Event Service와의 통합 테스트
- Kafka 이벤트 발행/구독 테스트

649
develop/dev/test-backend.md
View File

@ -1,426 +1,389 @@
# analytics-service 백엔드 테스트 결과
# Content Service 백엔드 테스트 결과서
**테스트 일시**: 2025-10-27 14:57
**테스트 대상**: analytics-service
**서버 포트**: 8086
**테스트 담당**: Claude Code
## 1. 테스트 개요
---
### 1.1 테스트 정보
- **테스트 일시**: 2025-10-23
- **테스트 환경**: Local 개발 환경
- **서비스명**: Content Service
- **서비스 포트**: 8084
- **프로파일**: local (H2 in-memory database)
- **테스트 대상**: REST API 7개 엔드포인트
## 1. 테스트 환경 검증
### 1.2 테스트 목적
- Content Service의 모든 REST API 엔드포인트 정상 동작 검증
- Mock 서비스 (MockGenerateImagesService, MockRedisGateway) 정상 동작 확인
- Local 환경에서 외부 인프라 의존성 없이 독립 실행 가능 여부 검증
### 1.1 설정 파일 검증
✅ **application.yml 환경 변수 처리 확인**
- 모든 설정이 환경변수 플레이스홀더 사용 (`${VARIABLE:default}` 형식)
- 하드코딩된 민감 정보 없음
## 2. 테스트 환경 구성
✅ **실행 프로파일 환경 변수 일치 확인**
- `.run/analytics-service.run.xml` 파일에 모든 환경 변수 정의됨
- application.yml과 실행 프로파일 간 환경 변수 일치 확인
### 2.1 데이터베이스
- **DB 타입**: H2 In-Memory Database
- **연결 URL**: jdbc:h2:mem:contentdb
- **스키마 생성**: 자동 (ddl-auto: create-drop)
- **생성된 테이블**:
- contents (콘텐츠 정보)
- generated_images (생성된 이미지 정보)
- jobs (작업 상태 추적)
### 1.2 서비스 상태 확인
✅ **Health Check**
```bash
$ curl http://localhost:8086/actuator/health
### 2.2 Mock 서비스
- **MockRedisGateway**: Redis 캐시 기능 Mock 구현
- **MockGenerateImagesService**: AI 이미지 생성 비동기 처리 Mock 구현
- 1초 지연 후 4개 이미지 자동 생성 (FANCY/SIMPLE x INSTAGRAM/KAKAO)
### 2.3 서버 시작 로그
```
Started ContentApplication in 2.856 seconds (process running for 3.212)
Hibernate: create table contents (...)
Hibernate: create table generated_images (...)
Hibernate: create table jobs (...)
```
**결과**:
- Status: UP
- Database (PostgreSQL): UP
- Redis: UP (version 7.2.3)
- Disk Space: UP
✅ **서비스 실행 확인**
- Port 8086 LISTENING 확인
- Process ID: 7312
---
## 2. 데이터 생성 검증
### 2.1 Kafka 이벤트 발행 확인
✅ **SampleDataLoader 정상 작동**
- EventCreated 이벤트 3건 발행 완료
- DistributionCompleted 이벤트 3건 발행 완료 (각 이벤트당 4개 채널 배열)
- ParticipantRegistered 이벤트 180건 발행 완료
### 2.2 Consumer 처리 확인
✅ **EventCreatedConsumer**
- Redis 멱등성 키 삭제 후 정상 처리
- EventStats 3건 생성 완료
✅ **DistributionCompletedConsumer**
- ChannelStats 12건 생성 완료 (3 이벤트 × 4 채널)
- EventStats의 totalViews 업데이트 완료
✅ **ParticipantRegisteredConsumer**
- 참여자 수 실시간 업데이트 확인
- evt_2025012301: 100명
- evt_2025020101: 50명
- evt_2025011501: 30명
### 2.3 TimelineData 생성 확인
✅ **TimelineData 생성**
- 3개 이벤트 × 30일 = 90건 생성 완료
- 2024-09-24부터 30일간 일별 데이터
---
## 3. API 테스트 결과
### 3.1 성과 대시보드 조회 API
**Endpoint**: `GET /api/v1/events/{eventId}/analytics`
### 3.1 POST /content/images/generate - 이미지 생성 요청
**Test Case 1: evt_2025012301**
**목적**: AI 이미지 생성 작업 시작
**요청**:
```bash
$ curl "http://localhost:8086/api/v1/events/evt_2025012301/analytics"
curl -X POST http://localhost:8084/content/images/generate \
-H "Content-Type: application/json" \
-d '{
"eventDraftId": 1,
"styles": ["FANCY", "SIMPLE"],
"platforms": ["INSTAGRAM", "KAKAO"]
}'
```
✅ **결과**: SUCCESS
**응답**:
- **HTTP 상태**: 202 Accepted
- **응답 본문**:
```json
{
"success": true,
"data": {
"eventId": "evt_2025012301",
"eventTitle": "신년맞이 20% 할인 이벤트",
"summary": {
"totalParticipants": 100,
"totalViews": 75000,
"totalReach": 205000,
"engagementRate": 0.1,
"conversionRate": 0.1
},
"roi": {
"totalInvestment": 5000000.0,
"roi": -100.0,
"costPerAcquisition": 50000.0
},
"dataSource": "cached"
}
"id": "job-mock-7ada8bd3",
"eventDraftId": 1,
"jobType": "image-generation",
"status": "PENDING",
"progress": 0,
"resultMessage": null,
"errorMessage": null,
"createdAt": "2025-10-23T21:52:57.511438",
"updatedAt": "2025-10-23T21:52:57.511438"
}
```
**Test Case 2: evt_2025020101**
```bash
$ curl "http://localhost:8086/api/v1/events/evt_2025020101/analytics"
```
✅ **결과**: SUCCESS
```json
{
"success": true,
"data": {
"eventId": "evt_2025020101",
"eventTitle": "설날 특가 선물세트 이벤트",
"summary": {
"totalParticipants": 50,
"totalViews": 75000
},
"roi": {
"totalInvestment": 3500000.0,
"costPerAcquisition": 70000.0
}
}
}
```
**검증 결과**: ✅ PASS
- Job이 정상적으로 생성되어 PENDING 상태로 반환됨
- 비동기 처리를 위한 Job ID 발급 확인
---
### 3.2 채널별 성과 분석 API
**Endpoint**: `GET /api/v1/events/{eventId}/analytics/channels`
### 3.2 GET /content/images/jobs/{jobId} - 작업 상태 조회
**Test Case: evt_2025012301**
**목적**: 이미지 생성 작업의 진행 상태 확인
**요청**:
```bash
$ curl "http://localhost:8086/api/v1/events/evt_2025012301/analytics/channels"
curl http://localhost:8084/content/images/jobs/job-mock-7ada8bd3
```
✅ **결과**: SUCCESS
**응답** (1초 후):
- **HTTP 상태**: 200 OK
- **응답 본문**:
```json
{
"success": true,
"data": {
"eventId": "evt_2025012301",
"channels": [
{
"channelName": "우리동네TV",
"channelType": "TV",
"metrics": {
"impressions": 120000,
"views": 45000,
"clicks": 5500
},
"performance": {
"clickThroughRate": 4.6,
"averageEngagementTime": 165,
"bounceRate": 35.8
},
"externalApiStatus": "success"
},
{
"channelName": "지니TV",
"channelType": "TV",
"metrics": {
"impressions": 80000,
"views": 30000,
"clicks": 3000
},
"performance": {
"clickThroughRate": 3.8
},
"externalApiStatus": "success"
},
{
"channelName": "링고비즈",
"channelType": "CALL",
"metrics": {
"impressions": 3000,
"voiceCallStats": {
"totalCalls": 3000,
"completedCalls": 2500,
"averageDuration": 45,
"completionRate": 83.3
"id": "job-mock-7ada8bd3",
"eventDraftId": 1,
"jobType": "image-generation",
"status": "COMPLETED",
"progress": 100,
"resultMessage": "4개의 이미지가 성공적으로 생성되었습니다.",
"errorMessage": null,
"createdAt": "2025-10-23T21:52:57.511438",
"updatedAt": "2025-10-23T21:52:58.571923"
}
},
"externalApiStatus": "success"
```
**검증 결과**: ✅ PASS
- Job 상태가 PENDING → COMPLETED로 정상 전환
- progress가 0 → 100으로 업데이트
- resultMessage에 생성 결과 포함
---
### 3.3 GET /content/events/{eventDraftId} - 이벤트 콘텐츠 조회
**목적**: 특정 이벤트의 전체 콘텐츠 정보 조회 (이미지 포함)
**요청**:
```bash
curl http://localhost:8084/content/events/1
```
**응답**:
- **HTTP 상태**: 200 OK
- **응답 본문**:
```json
{
"eventDraftId": 1,
"eventTitle": "Mock 이벤트 제목 1",
"eventDescription": "Mock 이벤트 설명입니다. 테스트를 위한 Mock 데이터입니다.",
"images": [
{
"id": 1,
"style": "FANCY",
"platform": "INSTAGRAM",
"cdnUrl": "https://mock-cdn.azure.com/images/1/fancy_instagram_7ada8bd3.png",
"prompt": "Mock prompt for FANCY style on INSTAGRAM platform",
"selected": true
},
{
"channelName": "SNS",
"channelType": "SNS",
"metrics": {
"impressions": 2000,
"socialInteractions": {
"likes": 3450,
"comments": 890,
"shares": 1250
}
"id": 2,
"style": "FANCY",
"platform": "KAKAO",
"cdnUrl": "https://mock-cdn.azure.com/images/1/fancy_kakao_3e2eaacf.png",
"prompt": "Mock prompt for FANCY style on KAKAO platform",
"selected": false
},
"externalApiStatus": "success"
{
"id": 3,
"style": "SIMPLE",
"platform": "INSTAGRAM",
"cdnUrl": "https://mock-cdn.azure.com/images/1/simple_instagram_56d91422.png",
"prompt": "Mock prompt for SIMPLE style on INSTAGRAM platform",
"selected": false
},
{
"id": 4,
"style": "SIMPLE",
"platform": "KAKAO",
"cdnUrl": "https://mock-cdn.azure.com/images/1/simple_kakao_7c9a666a.png",
"prompt": "Mock prompt for SIMPLE style on KAKAO platform",
"selected": false
}
],
"comparison": {
"bestPerforming": {
"byEngagement": "우리동네TV",
"byRoi": "우리동네TV",
"byViews": "우리동네TV"
}
}
}
"createdAt": "2025-10-23T21:52:57.52133",
"updatedAt": "2025-10-23T21:52:57.52133"
}
```
**검증 사항**:
- ✅ 4개 채널 모두 조회됨
- ✅ 채널별 타입에 맞는 metrics 제공 (TV: views, CALL: voiceCallStats, SNS: socialInteractions)
- ✅ 외부 API 호출 성공 (externalApiStatus: "success")
- ✅ 최고 성과 채널 비교 분석 제공
**검증 결과**: ✅ PASS
- 콘텐츠 정보와 생성된 이미지 목록이 모두 조회됨
- 4개 이미지 (FANCY/SIMPLE x INSTAGRAM/KAKAO) 생성 확인
- 첫 번째 이미지(FANCY+INSTAGRAM)가 selected:true로 설정됨
---
### 3.3 ROI 상세 분석 API
**Endpoint**: `GET /api/v1/events/{eventId}/analytics/roi`
### 3.4 GET /content/events/{eventDraftId}/images - 이미지 목록 조회
**Test Case: evt_2025012301**
**목적**: 특정 이벤트의 이미지 목록만 조회
**요청**:
```bash
$ curl "http://localhost:8086/api/v1/events/evt_2025012301/analytics/roi"
curl http://localhost:8084/content/events/1/images
```
✅ **결과**: SUCCESS
**응답**:
- **HTTP 상태**: 200 OK
- **응답 본문**: 4개의 이미지 객체 배열
```json
[
{
"success": true,
"data": {
"eventId": "evt_2025012301",
"investment": {
"contentCreation": 2000000.0,
"operation": 500000.0,
"total": 5000000.0
"id": 1,
"eventDraftId": 1,
"style": "FANCY",
"platform": "INSTAGRAM",
"cdnUrl": "https://mock-cdn.azure.com/images/1/fancy_instagram_7ada8bd3.png",
"prompt": "Mock prompt for FANCY style on INSTAGRAM platform",
"selected": true,
"createdAt": "2025-10-23T21:52:57.524759",
"updatedAt": "2025-10-23T21:52:57.524759"
},
"revenue": {
"directSales": 0.0,
"expectedSales": 0.0,
"total": 0.0
},
"roi": {
"netProfit": -5000000.0,
"roiPercentage": -100.0
},
"costEfficiency": {
"costPerParticipant": 50000.0,
"costPerConversion": 0.0,
"revenuePerParticipant": 0.0
},
"projection": {
"currentRevenue": 0.0,
"projectedFinalRevenue": 0.0,
"confidenceLevel": 85.5
}
}
}
```
**검증 사항**:
- ✅ 투자 내역 상세 분해 제공
- ✅ 수익 분석 (직접 매출, 예상 매출)
- ✅ ROI 계산 (순이익, ROI 퍼센티지)
- ✅ 비용 효율성 지표 (참여자당 비용, 전환당 비용)
- ✅ 예상 수익 프로젝션
---
### 3.4 시간대별 참여 추이 API
**Endpoint**: `GET /api/v1/events/{eventId}/analytics/timeline`
**Test Case: evt_2025012301 (daily interval)**
```bash
$ curl "http://localhost:8086/api/v1/events/evt_2025012301/analytics/timeline?interval=daily"
```
✅ **결과**: SUCCESS
```json
{
"success": true,
"data": {
"eventId": "evt_2025012301",
"interval": "daily",
"dataPoints": [
{
"timestamp": "2024-09-24T00:00:00",
"participants": 26,
"views": 130,
"engagement": 52,
"conversions": 16,
"cumulativeParticipants": 26
},
{
"timestamp": "2024-09-25T00:00:00",
"participants": 37,
"views": 148,
"engagement": 74,
"conversions": 23,
"cumulativeParticipants": 61
}
// ... 30일간 데이터
// ... 나머지 3개 이미지
]
}
```
**검증 결과**: ✅ PASS
- 이벤트에 속한 모든 이미지가 정상 조회됨
- createdAt, updatedAt 타임스탬프 포함
---
### 3.5 GET /content/images/{imageId} - 개별 이미지 상세 조회
**목적**: 특정 이미지의 상세 정보 조회
**요청**:
```bash
curl http://localhost:8084/content/images/1
```
**응답**:
- **HTTP 상태**: 200 OK
- **응답 본문**:
```json
{
"id": 1,
"eventDraftId": 1,
"style": "FANCY",
"platform": "INSTAGRAM",
"cdnUrl": "https://mock-cdn.azure.com/images/1/fancy_instagram_7ada8bd3.png",
"prompt": "Mock prompt for FANCY style on INSTAGRAM platform",
"selected": true,
"createdAt": "2025-10-23T21:52:57.524759",
"updatedAt": "2025-10-23T21:52:57.524759"
}
```
**검증 사항**:
- ✅ Daily 간격으로 30일간 데이터 제공
- ✅ 각 데이터 포인트에 참여자, 조회수, 참여행동, 전환수 포함
- ✅ 누적 참여자 수 계산 정확
**검증 결과**: ✅ PASS
- 개별 이미지 정보가 정상적으로 조회됨
- 모든 필드가 올바르게 반환됨
---
## 4. 주요 수정 사항
### 3.6 POST /content/images/{imageId}/regenerate - 이미지 재생성
### 4.1 Redis 멱등성 키 삭제 추가
**문제**: 서비스 재시작 시 Redis에 이전 멱등성 키가 남아있어 EventCreatedConsumer가 모든 이벤트를 "중복 이벤트"로 스킵
**목적**: 특정 이미지를 다시 생성하는 작업 시작
**해결**: SampleDataLoader에 Redis 멱등성 키 삭제 로직 추가
```java
// Redis 멱등성 키 삭제 (새로운 이벤트 처리를 위해)
redisTemplate.delete("processed_events");
redisTemplate.delete("distribution_completed");
redisTemplate.delete("processed_participants");
**요청**:
```bash
curl -X POST http://localhost:8084/content/images/1/regenerate \
-H "Content-Type: application/json"
```
**파일**: `analytics-service/src/main/java/com/kt/event/analytics/config/SampleDataLoader.java:85-90`
### 4.2 Kafka Timeout 설정 증가
**문제**: Kafka timeout이 너무 짧아 "Node disconnected" 발생
**해결**: application.yml의 Kafka properties 타임아웃 증가
```yaml
properties:
connections.max.idle.ms: 540000 # 10초 → 9분
request.timeout.ms: 30000 # 5초 → 30초
session.timeout.ms: 30000 # 10초 → 30초
heartbeat.interval.ms: 3000 # 새로 추가
max.poll.interval.ms: 300000 # 새로 추가: 5분
**응답**:
- **HTTP 상태**: 200 OK
- **응답 본문**:
```json
{
"id": "job-regen-df2bb3a3",
"eventDraftId": 999,
"jobType": "image-regeneration",
"status": "PENDING",
"progress": 0,
"resultMessage": null,
"errorMessage": null,
"createdAt": "2025-10-23T21:55:40.490627",
"updatedAt": "2025-10-23T21:55:40.490627"
}
```
**파일**: `analytics-service/src/main/resources/application.yml:59-64`
**검증 결과**: ✅ PASS
- 재생성 Job이 정상적으로 생성됨
- jobType이 "image-regeneration"으로 설정됨
- PENDING 상태로 시작
### 4.3 이벤트 처리 대기 시간 증가
**문제**: Consumer 처리 시간이 부족하여 race condition 발생
---
**해결**: SampleDataLoader의 대기 시간 증가
```java
// EventStats 생성 대기: 2초 → 5초
Thread.sleep(5000);
### 3.7 DELETE /content/images/{imageId} - 이미지 삭제
// ChannelStats 생성 대기: 1초 → 3초
Thread.sleep(3000);
**목적**: 특정 이미지 삭제
// 참여자 수 업데이트 대기: 2초 → 5초
Thread.sleep(5000);
**요청**:
```bash
curl -X DELETE http://localhost:8084/content/images/4
```
**파일**: `analytics-service/src/main/java/com/kt/event/analytics/config/SampleDataLoader.java:87-109`
**응답**:
- **HTTP 상태**: 204 No Content
- **응답 본문**: 없음 (정상)
**검증 결과**: ✅ PASS
- 삭제 요청이 정상적으로 처리됨
- HTTP 204 상태로 응답
**참고**: H2 in-memory 데이터베이스 특성상 물리적 삭제가 즉시 반영되지 않을 수 있음
---
## 5. 테스트 결과 요약
## 4. 종합 테스트 결과
### 5.1 성공 항목
✅ **설정 검증** (2/2)
- application.yml 환경 변수 처리 적합
- 실행 프로파일과 일치
### 4.1 테스트 요약
| API | Method | Endpoint | 상태 | 비고 |
|-----|--------|----------|------|------|
| 이미지 생성 | POST | /content/images/generate | ✅ PASS | Job 생성 확인 |
| 작업 조회 | GET | /content/images/jobs/{jobId} | ✅ PASS | 상태 전환 확인 |
| 콘텐츠 조회 | GET | /content/events/{eventDraftId} | ✅ PASS | 이미지 포함 조회 |
| 이미지 목록 | GET | /content/events/{eventDraftId}/images | ✅ PASS | 4개 이미지 확인 |
| 이미지 상세 | GET | /content/images/{imageId} | ✅ PASS | 단일 이미지 조회 |
| 이미지 재생성 | POST | /content/images/{imageId}/regenerate | ✅ PASS | 재생성 Job 확인 |
| 이미지 삭제 | DELETE | /content/images/{imageId} | ✅ PASS | 204 응답 확인 |
✅ **서비스 실행** (1/1)
- Health Check 정상
- Database, Redis 연결 정상
### 4.2 전체 결과
- **총 테스트 케이스**: 7개
- **성공**: 7개
- **실패**: 0개
- **성공률**: 100%
✅ **데이터 생성** (3/3)
- Kafka 이벤트 발행 정상
- Consumer 처리 정상
- TimelineData 생성 정상
## 5. 검증된 기능
✅ **API 테스트** (4/4)
- 성과 대시보드 조회 API ✅
- 채널별 성과 분석 API ✅
- ROI 상세 분석 API ✅
- 시간대별 참여 추이 API ✅
### 5.1 비즈니스 로직
✅ 이미지 생성 요청 → Job 생성 → 비동기 처리 → 완료 확인 흐름 정상 동작
✅ Mock 서비스를 통한 4개 조합(2 스타일 x 2 플랫폼) 이미지 자동 생성
✅ 첫 번째 이미지 자동 선택(selected:true) 로직 정상 동작
✅ Content와 GeneratedImage 엔티티 연관 관계 정상 동작
### 5.2 테스트 통계
- **총 테스트 케이스**: 10개
- **성공**: 10개 (100%)
- **실패**: 0개 (0%)
### 5.2 기술 구현
✅ Clean Architecture (Hexagonal Architecture) 구조 정상 동작
✅ @Profile 기반 환경별 Bean 선택 정상 동작 (Mock vs Production)
✅ H2 In-Memory 데이터베이스 자동 스키마 생성 및 데이터 저장
✅ @Async 비동기 처리 정상 동작
✅ Spring Data JPA 엔티티 관계 및 쿼리 정상 동작
✅ REST API 표준 HTTP 상태 코드 사용 (200, 202, 204)
### 5.3 성능 지표
- **평균 응답 시간**: ~200ms
- **데이터 소스**: Redis 캐시 (cached)
- **외부 API 호출**: 성공 (externalApiStatus: "success")
### 5.3 Mock 서비스
✅ MockGenerateImagesService: 1초 지연 후 이미지 생성 시뮬레이션
✅ MockRedisGateway: Redis 캐시 기능 Mock 구현
✅ Local 프로파일에서 외부 의존성 없이 독립 실행
---
## 6. 확인된 이슈 및 개선사항
## 6. 결론
### 6.1 경고 메시지 (Non-Critical)
```
WARN: Index "IDX_EVENT_DRAFT_ID" already exists
```
- **원인**: generated_images와 jobs 테이블에 동일한 이름의 인덱스 사용
- **영향**: H2에서만 발생하는 경고, 기능에 영향 없음
- **개선 방안**: 각 테이블별로 고유한 인덱스 이름 사용 권장
- `idx_generated_images_event_draft_id`
- `idx_jobs_event_draft_id`
✅ **analytics-service 백엔드 테스트 완료**
### 6.2 Redis 구현 현황
✅ **Production용 구현 완료**:
- RedisConfig.java - RedisTemplate 설정
- RedisGateway.java - Redis 읽기/쓰기 구현
모든 API 엔드포인트가 정상적으로 작동하며, Kafka 이벤트 기반 데이터 생성 및 처리가 안정적으로 수행됩니다. Redis 멱등성 키 삭제, Kafka timeout 증가, 이벤트 처리 대기 시간 조정을 통해 race condition과 연결 문제를 해결했습니다.
✅ **Local/Test용 Mock 구현**:
- MockRedisGateway - 캐시 기능 Mock
**배포 준비 상태**: ✅ READY
## 7. 다음 단계
---
### 7.1 추가 테스트 필요 사항
- [ ] 에러 케이스 테스트
- 존재하지 않는 eventDraftId 조회
- 존재하지 않는 imageId 조회
- 잘못된 요청 파라미터 (validation 테스트)
- [ ] 동시성 테스트
- 동일 이벤트에 대한 동시 이미지 생성 요청
- [ ] 성능 테스트
- 대량 이미지 생성 시 성능 측정
## 7. 참고 사항
### 7.2 통합 테스트
- [ ] PostgreSQL 연동 테스트 (Production 프로파일)
- [ ] Redis 실제 연동 테스트
- [ ] Kafka 메시지 발행/구독 테스트
- [ ] 타 서비스(event-service 등)와의 통합 테스트
### 7.1 테스트 데이터
- 이벤트 3개: evt_2025012301, evt_2025020101, evt_2025011501
- 채널 4개: 우리동네TV, 지니TV, 링고비즈, SNS
- 참여자: 총 180명 (100 + 50 + 30)
- 타임라인: 30일 × 3이벤트 = 90건
## 8. 결론
### 7.2 환경 정보
- **Database**: PostgreSQL (analyticdb)
- **Cache**: Redis (database 5)
- **Message Queue**: Kafka (2 brokers)
- Broker 1: 20.249.182.13:9095
- Broker 2: 4.217.131.59:9095
- **Consumer Group**: analytics-service-consumers
Content Service의 모든 핵심 REST API가 정상적으로 동작하며, Local 환경에서 Mock 서비스를 통해 독립적으로 실행 및 테스트 가능함을 확인했습니다.
### 7.3 다음 단계
1. 프론트엔드 연동 테스트
2. 부하 테스트 (동시 접속자 처리 확인)
3. 장애 복구 시나리오 테스트
4. 모니터링 대시보드 구성
### 주요 성과
1. ✅ 7개 API 엔드포인트 100% 정상 동작
2. ✅ Clean Architecture 구조 정상 동작
3. ✅ Profile 기반 환경 분리 정상 동작
4. ✅ 비동기 이미지 생성 흐름 정상 동작
5. ✅ Redis Gateway Production/Mock 구현 완료
---
**테스트 완료 일시**: 2025-10-27 14:57
Content Service는 Local 환경에서 완전히 검증되었으며, Production 환경 배포를 위한 준비가 완료되었습니다.

8
develop/mq/mq-exec-dev.md
View File

@ -3,9 +3,9 @@
## 설치 정보
### Kafka 브로커 정보
- **Host**: 4.230.50.63
- **Port**: 9092
- **Broker 주소**: 4.230.50.63:9092
- **Host**: 4.217.131.59
- **Port**: 9095
- **Broker 주소**: 4.217.131.59:9095
### Consumer Group ID 설정
| 서비스 | Consumer Group ID | 설명 |
@ -32,7 +32,7 @@ spring:
### 환경 변수 설정
```bash
export KAFKA_BOOTSTRAP_SERVERS=4.230.50.63:9092
export KAFKA_BOOTSTRAP_SERVERS=20.249.182.13:9095,4.217.131.59:9095
export KAFKA_CONSUMER_GROUP_ID=ai # 또는 analytic
```

3
event-service/build.gradle
View File

@ -10,4 +10,7 @@ dependencies {
// Jackson for JSON
implementation 'com.fasterxml.jackson.core:jackson-databind'
// Hibernate 6 네이티브로 배열 타입 지원하므로 별도 라이브러리 불필요
// implementation 'com.vladmihalcea:hibernate-types-60:2.21.1'
}

37
event-service/src/main/java/com/kt/event/eventservice/EventServiceApplication.java Normal file
View File

@ -0,0 +1,37 @@
package com.kt.event.eventservice;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
import org.springframework.kafka.annotation.EnableKafka;
/**
* Event Service Application
*
* 이벤트 전체 생명주기 관리 서비스
* - AI 기반 이벤트 추천 및 커스터마이징
* - 이미지 생성 및 편집 오케스트레이션
* - 배포 채널 관리 및 최종 배포
* - 이벤트 상태 관리 (DRAFT, PUBLISHED, ENDED)
*
* @version 1.0.0
* @since 2025-10-23
*/
@SpringBootApplication(
scanBasePackages = {
"com.kt.event.eventservice",
"com.kt.event.common"
},
exclude = {UserDetailsServiceAutoConfiguration.class}
)
@EnableJpaAuditing
@EnableKafka
@EnableFeignClients
public class EventServiceApplication {
public static void main(String[] args) {
SpringApplication.run(EventServiceApplication.class, args);
}
}

95
event-service/src/main/java/com/kt/event/eventservice/application/dto/kafka/AIEventGenerationJobMessage.java Normal file
View File

@ -0,0 +1,95 @@
package com.kt.event.eventservice.application.dto.kafka;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
import java.util.List;
/**
* AI 이벤트 생성 작업 메시지 DTO
*
* ai-event-generation-job 토픽에서 구독하는 메시지 형식
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class AIEventGenerationJobMessage {
/**
* 작업 ID
*/
@JsonProperty("job_id")
private String jobId;
/**
* 사용자 ID
*/
@JsonProperty("user_id")
private Long userId;
/**
* 작업 상태 (PENDING, PROCESSING, COMPLETED, FAILED)
*/
@JsonProperty("status")
private String status;
/**
* AI 추천 결과 데이터
*/
@JsonProperty("ai_recommendation")
private AIRecommendationData aiRecommendation;
/**
* 에러 메시지 (실패 시)
*/
@JsonProperty("error_message")
private String errorMessage;
/**
* 작업 생성 일시
*/
@JsonProperty("created_at")
private LocalDateTime createdAt;
/**
* 작업 완료/실패 일시
*/
@JsonProperty("completed_at")
private LocalDateTime completedAt;
/**
* AI 추천 데이터 내부 클래스
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public static class AIRecommendationData {
@JsonProperty("event_title")
private String eventTitle;
@JsonProperty("event_description")
private String eventDescription;
@JsonProperty("event_type")
private String eventType;
@JsonProperty("target_keywords")
private List<String> targetKeywords;
@JsonProperty("recommended_benefits")
private List<String> recommendedBenefits;
@JsonProperty("start_date")
private String startDate;
@JsonProperty("end_date")
private String endDate;
}
}

57
event-service/src/main/java/com/kt/event/eventservice/application/dto/kafka/EventCreatedMessage.java Normal file
View File

@ -0,0 +1,57 @@
package com.kt.event.eventservice.application.dto.kafka;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
/**
* 이벤트 생성 완료 메시지 DTO
*
* event-created 토픽에 발행되는 메시지 형식
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class EventCreatedMessage {
/**
* 이벤트 ID
*/
@JsonProperty("event_id")
private Long eventId;
/**
* 사용자 ID
*/
@JsonProperty("user_id")
private Long userId;
/**
* 이벤트 제목
*/
@JsonProperty("title")
private String title;
/**
* 이벤트 생성 일시
*/
@JsonProperty("created_at")
private LocalDateTime createdAt;
/**
* 이벤트 타입 (COUPON, DISCOUNT, GIFT, POINT 등)
*/
@JsonProperty("event_type")
private String eventType;
/**
* 메시지 타임스탬프
*/
@JsonProperty("timestamp")
private LocalDateTime timestamp;
}

75
event-service/src/main/java/com/kt/event/eventservice/application/dto/kafka/ImageGenerationJobMessage.java Normal file
View File

@ -0,0 +1,75 @@
package com.kt.event.eventservice.application.dto.kafka;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
/**
* 이미지 생성 작업 메시지 DTO
*
* image-generation-job 토픽에서 구독하는 메시지 형식
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ImageGenerationJobMessage {
/**
* 작업 ID
*/
@JsonProperty("job_id")
private String jobId;
/**
* 이벤트 ID
*/
@JsonProperty("event_id")
private Long eventId;
/**
* 사용자 ID
*/
@JsonProperty("user_id")
private Long userId;
/**
* 작업 상태 (PENDING, PROCESSING, COMPLETED, FAILED)
*/
@JsonProperty("status")
private String status;
/**
* 생성된 이미지 URL
*/
@JsonProperty("image_url")
private String imageUrl;
/**
* 이미지 생성 프롬프트
*/
@JsonProperty("prompt")
private String prompt;
/**
* 에러 메시지 (실패 시)
*/
@JsonProperty("error_message")
private String errorMessage;
/**
* 작업 생성 일시
*/
@JsonProperty("created_at")
private LocalDateTime createdAt;
/**
* 작업 완료/실패 일시
*/
@JsonProperty("completed_at")
private LocalDateTime completedAt;
}

24
event-service/src/main/java/com/kt/event/eventservice/application/dto/request/SelectObjectiveRequest.java Normal file
View File

@ -0,0 +1,24 @@
package com.kt.event.eventservice.application.dto.request;
import jakarta.validation.constraints.NotBlank;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 이벤트 목적 선택 요청 DTO
*
* @author Event Service Team
* @version 1.0.0
* @since 2025-10-23
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class SelectObjectiveRequest {
@NotBlank(message = "이벤트 목적은 필수입니다.")
private String objective;
}

29
event-service/src/main/java/com/kt/event/eventservice/application/dto/response/EventCreatedResponse.java Normal file
View File

@ -0,0 +1,29 @@
package com.kt.event.eventservice.application.dto.response;
import com.kt.event.eventservice.domain.enums.EventStatus;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
import java.util.UUID;
/**
* 이벤트 생성 응답 DTO
*
* @author Event Service Team
* @version 1.0.0
* @since 2025-10-23
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class EventCreatedResponse {
private UUID eventId;
private EventStatus status;
private String objective;
private LocalDateTime createdAt;
}

77
event-service/src/main/java/com/kt/event/eventservice/application/dto/response/EventDetailResponse.java Normal file
View File

@ -0,0 +1,77 @@
package com.kt.event.eventservice.application.dto.response;
import com.kt.event.eventservice.domain.enums.EventStatus;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
/**
* 이벤트 상세 응답 DTO
*
* @author Event Service Team
* @version 1.0.0
* @since 2025-10-23
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class EventDetailResponse {
private UUID eventId;
private UUID userId;
private UUID storeId;
private String eventName;
private String description;
private String objective;
private LocalDate startDate;
private LocalDate endDate;
private EventStatus status;
private UUID selectedImageId;
private String selectedImageUrl;
@Builder.Default
private List<GeneratedImageDto> generatedImages = new ArrayList<>();
@Builder.Default
private List<AiRecommendationDto> aiRecommendations = new ArrayList<>();
@Builder.Default
private List<String> channels = new ArrayList<>();
private LocalDateTime createdAt;
private LocalDateTime updatedAt;
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public static class GeneratedImageDto {
private UUID imageId;
private String imageUrl;
private String style;
private String platform;
private boolean isSelected;
private LocalDateTime createdAt;
}
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public static class AiRecommendationDto {
private UUID recommendationId;
private String eventName;
private String description;
private String promotionType;
private String targetAudience;
private boolean isSelected;
}
}

34
event-service/src/main/java/com/kt/event/eventservice/application/dto/response/JobStatusResponse.java Normal file
View File

@ -0,0 +1,34 @@
package com.kt.event.eventservice.application.dto.response;
import com.kt.event.eventservice.domain.enums.JobStatus;
import com.kt.event.eventservice.domain.enums.JobType;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;
import java.util.UUID;
/**
* Job 상태 응답 DTO
*
* @author Event Service Team
* @version 1.0.0
* @since 2025-10-23
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class JobStatusResponse {
private UUID jobId;
private JobType jobType;
private JobStatus status;
private int progress;
private String resultKey;
private String errorMessage;
private LocalDateTime createdAt;
private LocalDateTime completedAt;
}

236
event-service/src/main/java/com/kt/event/eventservice/application/service/EventService.java Normal file
View File

@ -0,0 +1,236 @@
package com.kt.event.eventservice.application.service;
import com.kt.event.common.exception.BusinessException;
import com.kt.event.common.exception.ErrorCode;
import com.kt.event.eventservice.application.dto.request.SelectObjectiveRequest;
import com.kt.event.eventservice.application.dto.response.EventCreatedResponse;
import com.kt.event.eventservice.application.dto.response.EventDetailResponse;
import com.kt.event.eventservice.domain.entity.*;
import com.kt.event.eventservice.domain.enums.EventStatus;
import com.kt.event.eventservice.domain.repository.EventRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.hibernate.Hibernate;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.UUID;
import java.util.stream.Collectors;
/**
* 이벤트 서비스
*
* 이벤트 전체 생명주기를 관리합니다.
*
* @author Event Service Team
* @version 1.0.0
* @since 2025-10-23
*/
@Slf4j
@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class EventService {
private final EventRepository eventRepository;
/**
* 이벤트 생성 (Step 1: 목적 선택)
*
* @param userId 사용자 ID (UUID)
* @param storeId 매장 ID (UUID)
* @param request 목적 선택 요청
* @return 생성된 이벤트 응답
*/
@Transactional
public EventCreatedResponse createEvent(UUID userId, UUID storeId, SelectObjectiveRequest request) {
log.info("이벤트 생성 시작 - userId: {}, storeId: {}, objective: {}",
userId, storeId, request.getObjective());
// 이벤트 엔티티 생성
Event event = Event.builder()
.userId(userId)
.storeId(storeId)
.objective(request.getObjective())
.eventName("") // 초기에는 비어있음, AI 추천 후 설정
.status(EventStatus.DRAFT)
.build();
// 저장
event = eventRepository.save(event);
log.info("이벤트 생성 완료 - eventId: {}", event.getEventId());
return EventCreatedResponse.builder()
.eventId(event.getEventId())
.status(event.getStatus())
.objective(event.getObjective())
.createdAt(event.getCreatedAt())
.build();
}
/**
* 이벤트 상세 조회
*
* @param userId 사용자 ID (UUID)
* @param eventId 이벤트 ID
* @return 이벤트 상세 응답
*/
public EventDetailResponse getEvent(UUID userId, UUID eventId) {
log.info("이벤트 조회 - userId: {}, eventId: {}", userId, eventId);
Event event = eventRepository.findByEventIdAndUserId(eventId, userId)
.orElseThrow(() -> new BusinessException(ErrorCode.EVENT_001));
// Lazy 컬렉션 초기화
Hibernate.initialize(event.getChannels());
Hibernate.initialize(event.getGeneratedImages());
Hibernate.initialize(event.getAiRecommendations());
return mapToDetailResponse(event);
}
/**
* 이벤트 목록 조회 (페이징, 필터링)
*
* @param userId 사용자 ID (UUID)
* @param status 상태 필터
* @param search 검색어
* @param objective 목적 필터
* @param pageable 페이징 정보
* @return 이벤트 목록
*/
public Page<EventDetailResponse> getEvents(
UUID userId,
EventStatus status,
String search,
String objective,
Pageable pageable) {
log.info("이벤트 목록 조회 - userId: {}, status: {}, search: {}, objective: {}",
userId, status, search, objective);
Page<Event> events = eventRepository.findEventsByUser(userId, status, search, objective, pageable);
return events.map(event -> {
// Lazy 컬렉션 초기화
Hibernate.initialize(event.getChannels());
Hibernate.initialize(event.getGeneratedImages());
Hibernate.initialize(event.getAiRecommendations());
return mapToDetailResponse(event);
});
}
/**
* 이벤트 삭제
*
* @param userId 사용자 ID (UUID)
* @param eventId 이벤트 ID
*/
@Transactional
public void deleteEvent(UUID userId, UUID eventId) {
log.info("이벤트 삭제 - userId: {}, eventId: {}", userId, eventId);
Event event = eventRepository.findByEventIdAndUserId(eventId, userId)
.orElseThrow(() -> new BusinessException(ErrorCode.EVENT_001));
if (!event.isDeletable()) {
throw new BusinessException(ErrorCode.EVENT_002);
}
eventRepository.delete(event);
log.info("이벤트 삭제 완료 - eventId: {}", eventId);
}
/**
* 이벤트 배포
*
* @param userId 사용자 ID (UUID)
* @param eventId 이벤트 ID
*/
@Transactional
public void publishEvent(UUID userId, UUID eventId) {
log.info("이벤트 배포 - userId: {}, eventId: {}", userId, eventId);
Event event = eventRepository.findByEventIdAndUserId(eventId, userId)
.orElseThrow(() -> new BusinessException(ErrorCode.EVENT_001));
// 배포 가능 여부 검증 및 상태 변경
event.publish();
eventRepository.save(event);
log.info("이벤트 배포 완료 - eventId: {}", eventId);
}
/**
* 이벤트 종료
*
* @param userId 사용자 ID (UUID)
* @param eventId 이벤트 ID
*/
@Transactional
public void endEvent(UUID userId, UUID eventId) {
log.info("이벤트 종료 - userId: {}, eventId: {}", userId, eventId);
Event event = eventRepository.findByEventIdAndUserId(eventId, userId)
.orElseThrow(() -> new BusinessException(ErrorCode.EVENT_001));
event.end();
eventRepository.save(event);
log.info("이벤트 종료 완료 - eventId: {}", eventId);
}
// ==== Private Helper Methods ==== //
/**
* Event Entity를 EventDetailResponse DTO로 변환
*/
private EventDetailResponse mapToDetailResponse(Event event) {
return EventDetailResponse.builder()
.eventId(event.getEventId())
.userId(event.getUserId())
.storeId(event.getStoreId())
.eventName(event.getEventName())
.description(event.getDescription())
.objective(event.getObjective())
.startDate(event.getStartDate())
.endDate(event.getEndDate())
.status(event.getStatus())
.selectedImageId(event.getSelectedImageId())
.selectedImageUrl(event.getSelectedImageUrl())
.generatedImages(
event.getGeneratedImages().stream()
.map(img -> EventDetailResponse.GeneratedImageDto.builder()
.imageId(img.getImageId())
.imageUrl(img.getImageUrl())
.style(img.getStyle())
.platform(img.getPlatform())
.isSelected(img.isSelected())
.createdAt(img.getCreatedAt())
.build())
.collect(Collectors.toList())
)
.aiRecommendations(
event.getAiRecommendations().stream()
.map(rec -> EventDetailResponse.AiRecommendationDto.builder()
.recommendationId(rec.getRecommendationId())
.eventName(rec.getEventName())
.description(rec.getDescription())
.promotionType(rec.getPromotionType())
.targetAudience(rec.getTargetAudience())
.isSelected(rec.isSelected())
.build())
.collect(Collectors.toList())
)
.channels(event.getChannels())
.createdAt(event.getCreatedAt())
.updatedAt(event.getUpdatedAt())
.build();
}
}

146
event-service/src/main/java/com/kt/event/eventservice/application/service/JobService.java Normal file
View File

@ -0,0 +1,146 @@
package com.kt.event.eventservice.application.service;
import com.kt.event.common.exception.BusinessException;
import com.kt.event.common.exception.ErrorCode;
import com.kt.event.eventservice.application.dto.response.JobStatusResponse;
import com.kt.event.eventservice.domain.entity.Job;
import com.kt.event.eventservice.domain.enums.JobType;
import com.kt.event.eventservice.domain.repository.JobRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.UUID;
/**
* Job 서비스
*
* 비동기 작업 상태를 관리합니다.
*
* @author Event Service Team
* @version 1.0.0
* @since 2025-10-23
*/
@Slf4j
@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class JobService {
private final JobRepository jobRepository;
/**
* Job 생성
*
* @param eventId 이벤트 ID
* @param jobType 작업 유형
* @return 생성된 Job
*/
@Transactional
public Job createJob(UUID eventId, JobType jobType) {
log.info("Job 생성 - eventId: {}, jobType: {}", eventId, jobType);
Job job = Job.builder()
.eventId(eventId)
.jobType(jobType)
.build();
job = jobRepository.save(job);
log.info("Job 생성 완료 - jobId: {}", job.getJobId());
return job;
}
/**
* Job 상태 조회
*
* @param jobId Job ID
* @return Job 상태 응답
*/
public JobStatusResponse getJobStatus(UUID jobId) {
log.info("Job 상태 조회 - jobId: {}", jobId);
Job job = jobRepository.findById(jobId)
.orElseThrow(() -> new BusinessException(ErrorCode.JOB_001));
return mapToJobStatusResponse(job);
}
/**
* Job 상태 업데이트
*
* @param jobId Job ID
* @param progress 진행률
*/
@Transactional
public void updateJobProgress(UUID jobId, int progress) {
log.info("Job 진행률 업데이트 - jobId: {}, progress: {}", jobId, progress);
Job job = jobRepository.findById(jobId)
.orElseThrow(() -> new BusinessException(ErrorCode.JOB_001));
job.updateProgress(progress);
jobRepository.save(job);
}
/**
* Job 완료 처리
*
* @param jobId Job ID
* @param resultKey Redis 결과 키
*/
@Transactional
public void completeJob(UUID jobId, String resultKey) {
log.info("Job 완료 - jobId: {}, resultKey: {}", jobId, resultKey);
Job job = jobRepository.findById(jobId)
.orElseThrow(() -> new BusinessException(ErrorCode.JOB_001));
job.complete(resultKey);
jobRepository.save(job);
log.info("Job 완료 처리 완료 - jobId: {}", jobId);
}
/**
* Job 실패 처리
*
* @param jobId Job ID
* @param errorMessage 에러 메시지
*/
@Transactional
public void failJob(UUID jobId, String errorMessage) {
log.info("Job 실패 - jobId: {}, errorMessage: {}", jobId, errorMessage);
Job job = jobRepository.findById(jobId)
.orElseThrow(() -> new BusinessException(ErrorCode.JOB_001));
job.fail(errorMessage);
jobRepository.save(job);
log.info("Job 실패 처리 완료 - jobId: {}", jobId);
}
// ==== Private Helper Methods ==== //
/**
* Job Entity를 JobStatusResponse DTO로 변환
*/
private JobStatusResponse mapToJobStatusResponse(Job job) {
return JobStatusResponse.builder()
.jobId(job.getJobId())
.jobType(job.getJobType())
.status(job.getStatus())
.progress(job.getProgress())
.resultKey(job.getResultKey())
.errorMessage(job.getErrorMessage())
.createdAt(job.getCreatedAt())
.completedAt(job.getCompletedAt())
.build();
}
}

53
event-service/src/main/java/com/kt/event/eventservice/config/DevAuthenticationFilter.java Normal file
View File

@ -0,0 +1,53 @@
package com.kt.event.eventservice.config;
import com.kt.event.common.security.UserPrincipal;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.filter.OncePerRequestFilter;
import java.io.IOException;
import java.util.Collections;
import java.util.UUID;
/**
* 개발 환경용 인증 필터
*
* User Service가 구현되지 않은 개발 환경에서 테스트를 위해
* 기본 UserPrincipal을 자동으로 생성하여 SecurityContext에 설정합니다.
*
* TODO: 프로덕션 환경에서는 이 필터를 비활성화하고 실제 JWT 인증 필터를 사용해야 합니다.
*/
public class DevAuthenticationFilter extends OncePerRequestFilter {
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
throws ServletException, IOException {
// 이미 인증된 경우 스킵
if (SecurityContextHolder.getContext().getAuthentication() != null) {
filterChain.doFilter(request, response);
return;
}
// 개발용 기본 UserPrincipal 생성
UserPrincipal userPrincipal = new UserPrincipal(
UUID.fromString("11111111-1111-1111-1111-111111111111"), // userId
UUID.fromString("22222222-2222-2222-2222-222222222222"), // storeId
"dev@test.com", // email
"개발테스트사용자", // name
Collections.singletonList("USER") // roles
);
// Authentication 객체 생성 및 SecurityContext에 설정
UsernamePasswordAuthenticationToken authentication =
new UsernamePasswordAuthenticationToken(userPrincipal, null, userPrincipal.getAuthorities());
SecurityContextHolder.getContext().setAuthentication(authentication);
filterChain.doFilter(request, response);
}
}

107
event-service/src/main/java/com/kt/event/eventservice/config/KafkaConfig.java Normal file
View File

@ -0,0 +1,107 @@
package com.kt.event.eventservice.config;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.core.*;
import org.springframework.kafka.listener.ContainerProperties;
import org.springframework.kafka.support.serializer.JsonDeserializer;
import org.springframework.kafka.support.serializer.JsonSerializer;
import java.util.HashMap;
import java.util.Map;
/**
* Kafka 설정 클래스
*
* Producer와 Consumer 설정을 정의합니다.
* - Producer: event-created 토픽에 이벤트 발행
* - Consumer: ai-event-generation-job, image-generation-job 토픽 구독
*/
@Configuration
@EnableKafka
public class KafkaConfig {
@Value("${spring.kafka.bootstrap-servers}")
private String bootstrapServers;
@Value("${spring.kafka.consumer.group-id}")
private String consumerGroupId;
/**
* Kafka Producer 설정
*
* @return ProducerFactory 인스턴스
*/
@Bean
public ProducerFactory<String, Object> producerFactory() {
Map<String, Object> config = new HashMap<>();
config.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
config.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
config.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, JsonSerializer.class);
config.put(JsonSerializer.ADD_TYPE_INFO_HEADERS, false);
// Producer 성능 최적화 설정
config.put(ProducerConfig.ACKS_CONFIG, "all");
config.put(ProducerConfig.RETRIES_CONFIG, 3);
config.put(ProducerConfig.LINGER_MS_CONFIG, 1);
config.put(ProducerConfig.COMPRESSION_TYPE_CONFIG, "snappy");
return new DefaultKafkaProducerFactory<>(config);
}
/**
* KafkaTemplate 빈 생성
*
* @return KafkaTemplate 인스턴스
*/
@Bean
public KafkaTemplate<String, Object> kafkaTemplate() {
return new KafkaTemplate<>(producerFactory());
}
/**
* Kafka Consumer 설정
*
* @return ConsumerFactory 인스턴스
*/
@Bean
public ConsumerFactory<String, Object> consumerFactory() {
Map<String, Object> config = new HashMap<>();
config.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
config.put(ConsumerConfig.GROUP_ID_CONFIG, consumerGroupId);
config.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
config.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, JsonDeserializer.class);
config.put(JsonDeserializer.TRUSTED_PACKAGES, "*");
config.put(JsonDeserializer.USE_TYPE_INFO_HEADERS, false);
config.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
config.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
// Consumer 성능 최적화 설정
config.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 500);
config.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, 300000);
return new DefaultKafkaConsumerFactory<>(config);
}
/**
* Kafka Listener Container Factory 설정
*
* @return ConcurrentKafkaListenerContainerFactory 인스턴스
*/
@Bean
public ConcurrentKafkaListenerContainerFactory<String, Object> kafkaListenerContainerFactory() {
ConcurrentKafkaListenerContainerFactory<String, Object> factory =
new ConcurrentKafkaListenerContainerFactory<>();
factory.setConsumerFactory(consumerFactory());
factory.setConcurrency(3); // 동시 처리 스레드 수
factory.getContainerProperties().setAckMode(ContainerProperties.AckMode.MANUAL);
return factory;
}
}

65
event-service/src/main/java/com/kt/event/eventservice/config/SecurityConfig.java Normal file
View File

@ -0,0 +1,65 @@
package com.kt.event.eventservice.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
/**
* Spring Security 설정 클래스
*
* 현재 User Service가 구현되지 않았으므로 임시로 모든 API 접근을 허용합니다.
* TODO: User Service 구현 후 JWT 기반 인증/인가 활성화 필요
*/
@Configuration
@EnableWebSecurity
public class SecurityConfig {
/**
* Spring Security 필터 체인 설정
* - 모든 요청에 대해 인증 없이 접근 허용
* - CSRF 보호 비활성화 (개발 환경)
*
* @param http HttpSecurity 설정 객체
* @return SecurityFilterChain 보안 필터 체인
* @throws Exception 설정 중 예외 발생 시
*/
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
// CSRF 보호 비활성화 (개발 환경)
.csrf(AbstractHttpConfigurer::disable)
// CORS 설정
.cors(AbstractHttpConfigurer::disable)
// 폼 로그인 비활성화
.formLogin(AbstractHttpConfigurer::disable)
// 로그아웃 비활성화
.logout(AbstractHttpConfigurer::disable)
// HTTP Basic 인증 비활성화
.httpBasic(AbstractHttpConfigurer::disable)
// 세션 관리 - STATELESS (세션 사용 안 함)
.sessionManagement(session -> session
.sessionCreationPolicy(SessionCreationPolicy.STATELESS)
)
// 요청 인증 설정
.authorizeHttpRequests(authz -> authz
// 모든 요청 허용 (개발 환경)
.anyRequest().permitAll()
)
// 개발용 인증 필터 추가 (User Service 구현 전까지 임시 사용)
.addFilterBefore(new DevAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);
return http.build();
}
}

53
event-service/src/main/java/com/kt/event/eventservice/domain/entity/AiRecommendation.java Normal file
View File

@ -0,0 +1,53 @@
package com.kt.event.eventservice.domain.entity;
import com.kt.event.common.entity.BaseTimeEntity;
import jakarta.persistence.*;
import lombok.*;
import org.hibernate.annotations.GenericGenerator;
import java.util.UUID;
/**
* AI 추천 엔티티
*
* AI가 추천한 이벤트 기획안을 관리합니다.
*
* @author Event Service Team
* @version 1.0.0
* @since 2025-10-23
*/
@Entity
@Table(name = "ai_recommendations")
@Getter
@Setter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor
@Builder
public class AiRecommendation extends BaseTimeEntity {
@Id
@GeneratedValue(generator = "uuid2")
@GenericGenerator(name = "uuid2", strategy = "uuid2")
@Column(name = "recommendation_id", columnDefinition = "uuid")
private UUID recommendationId;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "event_id", nullable = false)
private Event event;
@Column(name = "event_name", nullable = false, length = 200)
private String eventName;
@Column(name = "description", columnDefinition = "TEXT")
private String description;
@Column(name = "promotion_type", length = 50)
private String promotionType;
@Column(name = "target_audience", length = 100)
private String targetAudience;
@Column(name = "is_selected", nullable = false)
@Builder.Default
private boolean isSelected = false;
}

209
event-service/src/main/java/com/kt/event/eventservice/domain/entity/Event.java Normal file
View File

@ -0,0 +1,209 @@
package com.kt.event.eventservice.domain.entity;
import com.kt.event.common.entity.BaseTimeEntity;
import com.kt.event.eventservice.domain.enums.EventStatus;
import jakarta.persistence.*;
import lombok.*;
import org.hibernate.annotations.Fetch;
import org.hibernate.annotations.FetchMode;
import org.hibernate.annotations.GenericGenerator;
import java.time.LocalDate;
import java.util.*;
/**
* 이벤트 엔티티
*
* 이벤트의 전체 생명주기를 관리합니다.
* - 생성, 수정, 배포, 종료
* - AI 추천 및 이미지 관리
* - 배포 채널 관리
*
* @author Event Service Team
* @version 1.0.0
* @since 2025-10-23
*/
@Entity
@Table(name = "events")
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor
@Builder
public class Event extends BaseTimeEntity {
@Id
@GeneratedValue(generator = "uuid2")
@GenericGenerator(name = "uuid2", strategy = "uuid2")
@Column(name = "event_id", columnDefinition = "uuid")
private UUID eventId;
@Column(name = "user_id", nullable = false, columnDefinition = "uuid")
private UUID userId;
@Column(name = "store_id", nullable = false, columnDefinition = "uuid")
private UUID storeId;
@Column(name = "event_name", length = 200)
private String eventName;
@Column(name = "description", columnDefinition = "TEXT")
private String description;
@Column(name = "objective", nullable = false, length = 100)
private String objective;
@Column(name = "start_date")
private LocalDate startDate;
@Column(name = "end_date")
private LocalDate endDate;
@Enumerated(EnumType.STRING)
@Column(name = "status", nullable = false, length = 20)
@Builder.Default
private EventStatus status = EventStatus.DRAFT;
@Column(name = "selected_image_id", columnDefinition = "uuid")
private UUID selectedImageId;
@Column(name = "selected_image_url", length = 500)
private String selectedImageUrl;
@ElementCollection(fetch = FetchType.LAZY)
@CollectionTable(
name = "event_channels",
joinColumns = @JoinColumn(name = "event_id")
)
@Column(name = "channel", length = 50)
@Fetch(FetchMode.SUBSELECT)
@Builder.Default
private List<String> channels = new ArrayList<>();
@OneToMany(mappedBy = "event", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.LAZY)
@Builder.Default
private Set<GeneratedImage> generatedImages = new HashSet<>();
@OneToMany(mappedBy = "event", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.LAZY)
@Builder.Default
private Set<AiRecommendation> aiRecommendations = new HashSet<>();
// ==== 비즈니스 로직 ==== //
/**
* 이벤트명 수정
*/
public void updateEventName(String eventName) {
this.eventName = eventName;
}
/**
* 설명 수정
*/
public void updateDescription(String description) {
this.description = description;
}
/**
* 이벤트 기간 수정
*/
public void updateEventPeriod(LocalDate startDate, LocalDate endDate) {
if (startDate.isAfter(endDate)) {
throw new IllegalArgumentException("시작일은 종료일보다 이전이어야 합니다.");
}
this.startDate = startDate;
this.endDate = endDate;
}
/**
* 이미지 선택
*/
public void selectImage(UUID imageId, String imageUrl) {
this.selectedImageId = imageId;
this.selectedImageUrl = imageUrl;
// 기존 선택 해제
this.generatedImages.forEach(img -> img.setSelected(false));
// 새로운 이미지 선택
this.generatedImages.stream()
.filter(img -> img.getImageId().equals(imageId))
.findFirst()
.ifPresent(img -> img.setSelected(true));
}
/**
* 배포 채널 설정
*/
public void updateChannels(List<String> channels) {
this.channels.clear();
this.channels.addAll(channels);
}
/**
* 이벤트 배포 (상태 변경: DRAFT → PUBLISHED)
*/
public void publish() {
if (this.status != EventStatus.DRAFT) {
throw new IllegalStateException("DRAFT 상태에서만 배포할 수 있습니다.");
}
// 필수 데이터 검증
if (eventName == null || eventName.trim().isEmpty()) {
throw new IllegalStateException("이벤트명을 입력해야 합니다.");
}
if (startDate == null || endDate == null) {
throw new IllegalStateException("이벤트 기간을 설정해야 합니다.");
}
if (startDate.isAfter(endDate)) {
throw new IllegalStateException("시작일은 종료일보다 이전이어야 합니다.");
}
if (selectedImageId == null) {
throw new IllegalStateException("이미지를 선택해야 합니다.");
}
if (channels.isEmpty()) {
throw new IllegalStateException("배포 채널을 선택해야 합니다.");
}
this.status = EventStatus.PUBLISHED;
}
/**
* 이벤트 종료
*/
public void end() {
if (this.status != EventStatus.PUBLISHED) {
throw new IllegalStateException("PUBLISHED 상태에서만 종료할 수 있습니다.");
}
this.status = EventStatus.ENDED;
}
/**
* 생성된 이미지 추가
*/
public void addGeneratedImage(GeneratedImage image) {
this.generatedImages.add(image);
image.setEvent(this);
}
/**
* AI 추천 추가
*/
public void addAiRecommendation(AiRecommendation recommendation) {
this.aiRecommendations.add(recommendation);
recommendation.setEvent(this);
}
/**
* 수정 가능 여부 확인
*/
public boolean isModifiable() {
return this.status == EventStatus.DRAFT;
}
/**
* 삭제 가능 여부 확인
*/
public boolean isDeletable() {
return this.status == EventStatus.DRAFT;
}
}

50
event-service/src/main/java/com/kt/event/eventservice/domain/entity/GeneratedImage.java Normal file
View File

@ -0,0 +1,50 @@
package com.kt.event.eventservice.domain.entity;
import com.kt.event.common.entity.BaseTimeEntity;
import jakarta.persistence.*;
import lombok.*;
import org.hibernate.annotations.GenericGenerator;
import java.util.UUID;
/**
* 생성된 이미지 엔티티
*
* 이벤트별로 생성된 이미지를 관리합니다.
*
* @author Event Service Team
* @version 1.0.0
* @since 2025-10-23
*/
@Entity
@Table(name = "generated_images")
@Getter
@Setter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor
@Builder
public class GeneratedImage extends BaseTimeEntity {
@Id
@GeneratedValue(generator = "uuid2")
@GenericGenerator(name = "uuid2", strategy = "uuid2")
@Column(name = "image_id", columnDefinition = "uuid")
private UUID imageId;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "event_id", nullable = false)
private Event event;
@Column(name = "image_url", nullable = false, length = 500)
private String imageUrl;
@Column(name = "style", length = 50)
private String style;
@Column(name = "platform", length = 50)
private String platform;
@Column(name = "is_selected", nullable = false)
@Builder.Default
private boolean isSelected = false;
}

100
event-service/src/main/java/com/kt/event/eventservice/domain/entity/Job.java Normal file
View File

@ -0,0 +1,100 @@
package com.kt.event.eventservice.domain.entity;
import com.kt.event.common.entity.BaseTimeEntity;
import com.kt.event.eventservice.domain.enums.JobStatus;
import com.kt.event.eventservice.domain.enums.JobType;
import jakarta.persistence.*;
import lombok.*;
import org.hibernate.annotations.GenericGenerator;
import java.time.LocalDateTime;
import java.util.UUID;
/**
* 비동기 작업 엔티티
*
* AI 추천 생성, 이미지 생성 등의 비동기 작업 상태를 관리합니다.
*
* @author Event Service Team
* @version 1.0.0
* @since 2025-10-23
*/
@Entity
@Table(name = "jobs")
@Getter
@Setter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor
@Builder
public class Job extends BaseTimeEntity {
@Id
@GeneratedValue(generator = "uuid2")
@GenericGenerator(name = "uuid2", strategy = "uuid2")
@Column(name = "job_id", columnDefinition = "uuid")
private UUID jobId;
@Column(name = "event_id", nullable = false, columnDefinition = "uuid")
private UUID eventId;
@Enumerated(EnumType.STRING)
@Column(name = "job_type", nullable = false, length = 30)
private JobType jobType;
@Enumerated(EnumType.STRING)
@Column(name = "status", nullable = false, length = 20)
@Builder.Default
private JobStatus status = JobStatus.PENDING;
@Column(name = "progress", nullable = false)
@Builder.Default
private int progress = 0;
@Column(name = "result_key", length = 200)
private String resultKey;
@Column(name = "error_message", length = 500)
private String errorMessage;
@Column(name = "completed_at")
private LocalDateTime completedAt;
// ==== 비즈니스 로직 ==== //
/**
* 작업 시작
*/
public void start() {
this.status = JobStatus.PROCESSING;
this.progress = 0;
}
/**
* 진행률 업데이트
*/
public void updateProgress(int progress) {
if (progress < 0 || progress > 100) {
throw new IllegalArgumentException("진행률은 0~100 사이여야 합니다.");
}
this.progress = progress;
}
/**
* 작업 완료
*/
public void complete(String resultKey) {
this.status = JobStatus.COMPLETED;
this.progress = 100;
this.resultKey = resultKey;
this.completedAt = LocalDateTime.now();
}
/**
* 작업 실패
*/
public void fail(String errorMessage) {
this.status = JobStatus.FAILED;
this.errorMessage = errorMessage;
this.completedAt = LocalDateTime.now();
}
}

25
event-service/src/main/java/com/kt/event/eventservice/domain/enums/EventStatus.java Normal file
View File

@ -0,0 +1,25 @@
package com.kt.event.eventservice.domain.enums;
/**
* 이벤트 상태
*
* @author Event Service Team
* @version 1.0.0
* @since 2025-10-23
*/
public enum EventStatus {
/**
* 임시 저장 (작성 중)
*/
DRAFT,
/**
* 배포됨 (진행 중)
*/
PUBLISHED,
/**
* 종료됨
*/
ENDED
}

30
event-service/src/main/java/com/kt/event/eventservice/domain/enums/JobStatus.java Normal file
View File

@ -0,0 +1,30 @@
package com.kt.event.eventservice.domain.enums;
/**
* 비동기 작업 상태
*
* @author Event Service Team
* @version 1.0.0
* @since 2025-10-23
*/
public enum JobStatus {
/**
* 대기 중
*/
PENDING,
/**
* 처리 중
*/
PROCESSING,
/**
* 완료
*/
COMPLETED,
/**
* 실패
*/
FAILED
}

20
event-service/src/main/java/com/kt/event/eventservice/domain/enums/JobType.java Normal file
View File

@ -0,0 +1,20 @@
package com.kt.event.eventservice.domain.enums;
/**
* 비동기 작업 유형
*
* @author Event Service Team
* @version 1.0.0
* @since 2025-10-23
*/
public enum JobType {
/**
* AI 이벤트 추천 생성
*/
AI_RECOMMENDATION,
/**
* 이미지 생성
*/
IMAGE_GENERATION
}

29
event-service/src/main/java/com/kt/event/eventservice/domain/repository/AiRecommendationRepository.java Normal file
View File

@ -0,0 +1,29 @@
package com.kt.event.eventservice.domain.repository;
import com.kt.event.eventservice.domain.entity.AiRecommendation;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.UUID;
/**
* AI 추천 Repository
*
* @author Event Service Team
* @version 1.0.0
* @since 2025-10-23
*/
@Repository
public interface AiRecommendationRepository extends JpaRepository<AiRecommendation, UUID> {
/**
* 이벤트별 AI 추천 목록 조회
*/
List<AiRecommendation> findByEventEventId(UUID eventId);
/**
* 이벤트별 선택된 AI 추천 조회
*/
AiRecommendation findByEventEventIdAndIsSelectedTrue(UUID eventId);
}

56
event-service/src/main/java/com/kt/event/eventservice/domain/repository/EventRepository.java Normal file
View File

@ -0,0 +1,56 @@
package com.kt.event.eventservice.domain.repository;
import com.kt.event.eventservice.domain.entity.Event;
import com.kt.event.eventservice.domain.enums.EventStatus;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import java.util.Optional;
import java.util.UUID;
/**
* 이벤트 Repository
*
* @author Event Service Team
* @version 1.0.0
* @since 2025-10-23
*/
@Repository
public interface EventRepository extends JpaRepository<Event, UUID> {
/**
* 사용자 ID와 이벤트 ID로 조회
*/
@Query("SELECT DISTINCT e FROM Event e " +
"LEFT JOIN FETCH e.channels " +
"WHERE e.eventId = :eventId AND e.userId = :userId")
Optional<Event> findByEventIdAndUserId(
@Param("eventId") UUID eventId,
@Param("userId") UUID userId
);
/**
* 사용자별 이벤트 목록 조회 (페이징, 상태 필터)
*/
@Query("SELECT e FROM Event e " +
"WHERE e.userId = :userId " +
"AND (:status IS NULL OR e.status = :status) " +
"AND (:search IS NULL OR e.eventName LIKE %:search%) " +
"AND (:objective IS NULL OR e.objective = :objective)")
Page<Event> findEventsByUser(
@Param("userId") UUID userId,
@Param("status") EventStatus status,
@Param("search") String search,
@Param("objective") String objective,
Pageable pageable
);
/**
* 사용자별 이벤트 개수 조회 (상태별)
*/
long countByUserIdAndStatus(UUID userId, EventStatus status);
}

29
event-service/src/main/java/com/kt/event/eventservice/domain/repository/GeneratedImageRepository.java Normal file
View File

@ -0,0 +1,29 @@
package com.kt.event.eventservice.domain.repository;
import com.kt.event.eventservice.domain.entity.GeneratedImage;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.UUID;
/**
* 생성된 이미지 Repository
*
* @author Event Service Team
* @version 1.0.0
* @since 2025-10-23
*/
@Repository
public interface GeneratedImageRepository extends JpaRepository<GeneratedImage, UUID> {
/**
* 이벤트별 생성된 이미지 목록 조회
*/
List<GeneratedImage> findByEventEventId(UUID eventId);
/**
* 이벤트별 선택된 이미지 조회
*/
GeneratedImage findByEventEventIdAndIsSelectedTrue(UUID eventId);
}

42
event-service/src/main/java/com/kt/event/eventservice/domain/repository/JobRepository.java Normal file
View File

@ -0,0 +1,42 @@
package com.kt.event.eventservice.domain.repository;
import com.kt.event.eventservice.domain.entity.Job;
import com.kt.event.eventservice.domain.enums.JobStatus;
import com.kt.event.eventservice.domain.enums.JobType;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
/**
* 비동기 작업 Repository
*
* @author Event Service Team
* @version 1.0.0
* @since 2025-10-23
*/
@Repository
public interface JobRepository extends JpaRepository<Job, UUID> {
/**
* 이벤트별 작업 목록 조회
*/
List<Job> findByEventId(UUID eventId);
/**
* 이벤트 및 작업 유형별 조회
*/
Optional<Job> findByEventIdAndJobType(UUID eventId, JobType jobType);
/**
* 이벤트 및 작업 유형별 최신 작업 조회
*/
Optional<Job> findFirstByEventIdAndJobTypeOrderByCreatedAtDesc(UUID eventId, JobType jobType);
/**
* 상태별 작업 목록 조회
*/
List<Job> findByStatus(JobStatus status);
}

102
event-service/src/main/java/com/kt/event/eventservice/infrastructure/kafka/AIJobKafkaConsumer.java Normal file
View File

@ -0,0 +1,102 @@
package com.kt.event.eventservice.infrastructure.kafka;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.kt.event.eventservice.application.dto.kafka.AIEventGenerationJobMessage;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.support.Acknowledgment;
import org.springframework.kafka.support.KafkaHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;
/**
* AI 이벤트 생성 작업 메시지 구독 Consumer
*
* ai-event-generation-job 토픽의 메시지를 구독하여 처리합니다.
*/
@Slf4j
@Component
@RequiredArgsConstructor
public class AIJobKafkaConsumer {
private final ObjectMapper objectMapper;
/**
* AI 이벤트 생성 작업 메시지 수신 처리
*
* @param message AI 이벤트 생성 작업 메시지
* @param partition 파티션 번호
* @param offset 오프셋
* @param acknowledgment 수동 커밋용 Acknowledgment
*/
@KafkaListener(
topics = "${app.kafka.topics.ai-event-generation-job}",
groupId = "${spring.kafka.consumer.group-id}",
containerFactory = "kafkaListenerContainerFactory"
)
public void consumeAIEventGenerationJob(
@Payload String payload,
@Header(KafkaHeaders.RECEIVED_PARTITION) int partition,
@Header(KafkaHeaders.OFFSET) long offset,
Acknowledgment acknowledgment
) {
try {
log.info("AI 이벤트 생성 작업 메시지 수신 - Partition: {}, Offset: {}", partition, offset);
// JSON을 객체로 변환
AIEventGenerationJobMessage message = objectMapper.readValue(
payload,
AIEventGenerationJobMessage.class
);
log.info("AI 작업 메시지 파싱 완료 - JobId: {}, UserId: {}, Status: {}",
message.getJobId(), message.getUserId(), message.getStatus());
// 메시지 처리 로직
processAIEventGenerationJob(message);
// 수동 커밋
acknowledgment.acknowledge();
log.info("AI 이벤트 생성 작업 메시지 처리 완료 - JobId: {}", message.getJobId());
} catch (Exception e) {
log.error("AI 이벤트 생성 작업 메시지 처리 중 오류 발생 - Partition: {}, Offset: {}, Error: {}",
partition, offset, e.getMessage(), e);
// 에러 발생 시에도 커밋 (재처리 방지, DLQ 사용 권장)
acknowledgment.acknowledge();
}
}
/**
* AI 이벤트 생성 작업 처리
*
* @param message AI 이벤트 생성 작업 메시지
*/
private void processAIEventGenerationJob(AIEventGenerationJobMessage message) {
switch (message.getStatus()) {
case "COMPLETED":
log.info("AI 작업 완료 처리 - JobId: {}, UserId: {}",
message.getJobId(), message.getUserId());
// TODO: AI 추천 결과를 캐시 또는 DB에 저장
// TODO: 사용자에게 알림 전송
break;
case "FAILED":
log.error("AI 작업 실패 처리 - JobId: {}, Error: {}",
message.getJobId(), message.getErrorMessage());
// TODO: 실패 로그 저장 및 사용자 알림
break;
case "PROCESSING":
log.info("AI 작업 진행 중 - JobId: {}", message.getJobId());
// TODO: 작업 상태 업데이트
break;
default:
log.warn("알 수 없는 작업 상태 - JobId: {}, Status: {}",
message.getJobId(), message.getStatus());
}
}
}

78
event-service/src/main/java/com/kt/event/eventservice/infrastructure/kafka/EventKafkaProducer.java Normal file
View File

@ -0,0 +1,78 @@
package com.kt.event.eventservice.infrastructure.kafka;
import com.kt.event.eventservice.application.dto.kafka.EventCreatedMessage;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.util.concurrent.CompletableFuture;
/**
* 이벤트 생성 메시지 발행 Producer
*
* event-created 토픽에 이벤트 생성 완료 메시지를 발행합니다.
*/
@Slf4j
@Component
@RequiredArgsConstructor
public class EventKafkaProducer {
private final KafkaTemplate<String, Object> kafkaTemplate;
@Value("${app.kafka.topics.event-created}")
private String eventCreatedTopic;
/**
* 이벤트 생성 완료 메시지 발행
*
* @param eventId 이벤트 ID
* @param userId 사용자 ID
* @param title 이벤트 제목
* @param eventType 이벤트 타입
*/
public void publishEventCreated(Long eventId, Long userId, String title, String eventType) {
EventCreatedMessage message = EventCreatedMessage.builder()
.eventId(eventId)
.userId(userId)
.title(title)
.eventType(eventType)
.createdAt(LocalDateTime.now())
.timestamp(LocalDateTime.now())
.build();
publishEventCreatedMessage(message);
}
/**
* 이벤트 생성 메시지 발행
*
* @param message EventCreatedMessage 객체
*/
public void publishEventCreatedMessage(EventCreatedMessage message) {
try {
CompletableFuture<SendResult<String, Object>> future =
kafkaTemplate.send(eventCreatedTopic, message.getEventId().toString(), message);
future.whenComplete((result, ex) -> {
if (ex == null) {
log.info("이벤트 생성 메시지 발행 성공 - Topic: {}, EventId: {}, Offset: {}",
eventCreatedTopic,
message.getEventId(),
result.getRecordMetadata().offset());
} else {
log.error("이벤트 생성 메시지 발행 실패 - Topic: {}, EventId: {}, Error: {}",
eventCreatedTopic,
message.getEventId(),
ex.getMessage(), ex);
}
});
} catch (Exception e) {
log.error("이벤트 생성 메시지 발행 중 예외 발생 - EventId: {}, Error: {}",
message.getEventId(), e.getMessage(), e);
}
}
}

Some files were not shown because too many files have changed in this diff Show More