mirror of
https://github.com/ktds-dg0501/kt-event-marketing.git
synced 2026-06-13 06:59:10 +00:00
Merge branch 'origin/develop' into develop
- 이벤트 ID 단순화 변경사항 병합 (1, 2, 3) - 원격 변경사항 통합 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Hyowon Yang
+2
-2
@@ -63,7 +63,7 @@ public class AnalyticsBatchScheduler {
|
||||
event.getEventId(), event.getEventTitle());
|
||||
|
||||
// refresh=true로 호출하여 캐시 갱신 및 외부 API 호출
|
||||
analyticsService.getDashboardData(event.getEventId(), null, null, true);
|
||||
analyticsService.getDashboardData(event.getEventId(), true);
|
||||
|
||||
successCount++;
|
||||
log.info("✅ 배치 갱신 완료: eventId={}", event.getEventId());
|
||||
@@ -99,7 +99,7 @@ public class AnalyticsBatchScheduler {
|
||||
|
||||
for (EventStats event : allEvents) {
|
||||
try {
|
||||
analyticsService.getDashboardData(event.getEventId(), null, null, true);
|
||||
analyticsService.getDashboardData(event.getEventId(), true);
|
||||
log.debug("초기 데이터 로딩 완료: eventId={}", event.getEventId());
|
||||
} catch (Exception e) {
|
||||
log.warn("초기 데이터 로딩 실패: eventId={}, error={}",
|
||||
|
||||
+1
-1
@@ -17,7 +17,7 @@ import java.util.Map;
|
||||
* Kafka Consumer 설정
|
||||
*/
|
||||
@Configuration
|
||||
@ConditionalOnProperty(name = "spring.kafka.enabled", havingValue = "true", matchIfMissing = true)
|
||||
@ConditionalOnProperty(name = "spring.kafka.enabled", havingValue = "true", matchIfMissing = false)
|
||||
public class KafkaConsumerConfig {
|
||||
|
||||
@Value("${spring.kafka.bootstrap-servers}")
|
||||
|
||||
+46
@@ -0,0 +1,46 @@
|
||||
package com.kt.event.analytics.config;
|
||||
|
||||
import org.apache.kafka.clients.producer.ProducerConfig;
|
||||
import org.apache.kafka.common.serialization.StringSerializer;
|
||||
import org.springframework.beans.factory.annotation.Value;
|
||||
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
|
||||
import org.springframework.context.annotation.Bean;
|
||||
import org.springframework.context.annotation.Configuration;
|
||||
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
|
||||
import org.springframework.kafka.core.KafkaTemplate;
|
||||
import org.springframework.kafka.core.ProducerFactory;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Kafka Producer 설정
|
||||
*
|
||||
* ⚠️ MVP 전용: SampleDataLoader가 Kafka 이벤트를 발행하기 위해 필요
|
||||
* ⚠️ 실제 운영: Analytics Service는 순수 Consumer 역할만 수행하므로 Producer 불필요
|
||||
*
|
||||
* String 직렬화 방식 사용 (SampleDataLoader가 JSON 문자열을 직접 발행)
|
||||
*/
|
||||
@Configuration
|
||||
@ConditionalOnProperty(name = "spring.kafka.enabled", havingValue = "true", matchIfMissing = false)
|
||||
public class KafkaProducerConfig {
|
||||
|
||||
@Value("${spring.kafka.bootstrap-servers}")
|
||||
private String bootstrapServers;
|
||||
|
||||
@Bean
|
||||
public ProducerFactory<String, String> producerFactory() {
|
||||
Map<String, Object> configProps = new HashMap<>();
|
||||
configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
|
||||
configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
|
||||
configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
|
||||
configProps.put(ProducerConfig.ACKS_CONFIG, "all");
|
||||
configProps.put(ProducerConfig.RETRIES_CONFIG, 3);
|
||||
return new DefaultKafkaProducerFactory<>(configProps);
|
||||
}
|
||||
|
||||
@Bean
|
||||
public KafkaTemplate<String, String> kafkaTemplate() {
|
||||
return new KafkaTemplate<>(producerFactory());
|
||||
}
|
||||
}
|
||||
+191
-54
@@ -11,19 +11,22 @@ import jakarta.annotation.PreDestroy;
|
||||
import jakarta.persistence.EntityManager;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.apache.kafka.clients.admin.AdminClient;
|
||||
import org.apache.kafka.clients.admin.DeleteConsumerGroupOffsetsResult;
|
||||
import org.apache.kafka.clients.admin.ListConsumerGroupOffsetsResult;
|
||||
import org.apache.kafka.common.TopicPartition;
|
||||
import org.springframework.boot.ApplicationArguments;
|
||||
import org.springframework.boot.ApplicationRunner;
|
||||
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
|
||||
import org.springframework.data.redis.core.RedisTemplate;
|
||||
import org.springframework.kafka.core.KafkaAdmin;
|
||||
import org.springframework.kafka.core.KafkaTemplate;
|
||||
import org.springframework.stereotype.Component;
|
||||
import org.springframework.transaction.annotation.Transactional;
|
||||
|
||||
import java.math.BigDecimal;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Random;
|
||||
import java.util.UUID;
|
||||
import java.util.*;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
/**
|
||||
* 샘플 데이터 로더 (Kafka Producer 방식)
|
||||
@@ -47,6 +50,7 @@ import java.util.UUID;
|
||||
public class SampleDataLoader implements ApplicationRunner {
|
||||
|
||||
private final KafkaTemplate<String, String> kafkaTemplate;
|
||||
private final KafkaAdmin kafkaAdmin;
|
||||
private final ObjectMapper objectMapper;
|
||||
private final EventStatsRepository eventStatsRepository;
|
||||
private final ChannelStatsRepository channelStatsRepository;
|
||||
@@ -56,6 +60,8 @@ public class SampleDataLoader implements ApplicationRunner {
|
||||
|
||||
private final Random random = new Random();
|
||||
|
||||
private static final String CONSUMER_GROUP_ID = "analytics-service-consumers-v3";
|
||||
|
||||
// Kafka Topic Names (MVP용 샘플 토픽)
|
||||
private static final String EVENT_CREATED_TOPIC = "sample.event.created";
|
||||
private static final String PARTICIPANT_REGISTERED_TOPIC = "sample.participant.registered";
|
||||
@@ -85,9 +91,9 @@ public class SampleDataLoader implements ApplicationRunner {
|
||||
|
||||
// Redis 멱등성 키 삭제 (새로운 이벤트 처리를 위해)
|
||||
log.info("Redis 멱등성 키 삭제 중...");
|
||||
redisTemplate.delete("processed_events");
|
||||
redisTemplate.delete("distribution_completed");
|
||||
redisTemplate.delete("processed_participants");
|
||||
redisTemplate.delete("processed_events_v2");
|
||||
redisTemplate.delete("distribution_completed_v2");
|
||||
redisTemplate.delete("processed_participants_v2");
|
||||
log.info("✅ Redis 멱등성 키 삭제 완료");
|
||||
|
||||
try {
|
||||
@@ -103,6 +109,8 @@ public class SampleDataLoader implements ApplicationRunner {
|
||||
|
||||
// 3. ParticipantRegistered 이벤트 발행 (각 이벤트당 다수 참여자)
|
||||
publishParticipantRegisteredEvents();
|
||||
log.info("⏳ 참여자 등록 이벤트 처리 대기 중... (20초)");
|
||||
Thread.sleep(20000); // ParticipantRegisteredConsumer가 180개 이벤트 처리할 시간 (비관적 락 고려)
|
||||
|
||||
log.info("========================================");
|
||||
log.info("🎉 Kafka 이벤트 발행 완료! (Consumer가 처리 중...)");
|
||||
@@ -127,16 +135,17 @@ public class SampleDataLoader implements ApplicationRunner {
|
||||
}
|
||||
|
||||
/**
|
||||
* 서비스 종료 시 전체 데이터 삭제
|
||||
* 서비스 종료 시 전체 데이터 삭제 및 Consumer Offset 리셋
|
||||
*/
|
||||
@PreDestroy
|
||||
@Transactional
|
||||
public void onShutdown() {
|
||||
log.info("========================================");
|
||||
log.info("🛑 서비스 종료: PostgreSQL 전체 데이터 삭제");
|
||||
log.info("🛑 서비스 종료: PostgreSQL 전체 데이터 삭제 + Kafka Consumer Offset 리셋");
|
||||
log.info("========================================");
|
||||
|
||||
try {
|
||||
// 1. PostgreSQL 데이터 삭제
|
||||
long timelineCount = timelineDataRepository.count();
|
||||
long channelCount = channelStatsRepository.count();
|
||||
long eventCount = eventStatsRepository.count();
|
||||
@@ -153,6 +162,10 @@ public class SampleDataLoader implements ApplicationRunner {
|
||||
entityManager.clear();
|
||||
|
||||
log.info("✅ 모든 샘플 데이터 삭제 완료!");
|
||||
|
||||
// 2. Kafka Consumer Offset 리셋 (다음 시작 시 처음부터 읽도록)
|
||||
resetConsumerOffsets();
|
||||
|
||||
log.info("========================================");
|
||||
|
||||
} catch (Exception e) {
|
||||
@@ -160,36 +173,78 @@ public class SampleDataLoader implements ApplicationRunner {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Kafka Consumer Group Offset 리셋
|
||||
*
|
||||
* 서비스 종료 시 Consumer offset을 삭제하여 다음 시작 시
|
||||
* auto.offset.reset=earliest 설정에 따라 처음부터 읽도록 함
|
||||
*/
|
||||
private void resetConsumerOffsets() {
|
||||
try (AdminClient adminClient = AdminClient.create(kafkaAdmin.getConfigurationProperties())) {
|
||||
log.info("🔄 Kafka Consumer Offset 리셋 시작: group={}", CONSUMER_GROUP_ID);
|
||||
|
||||
// 모든 토픽의 offset 삭제
|
||||
Set<TopicPartition> partitions = new HashSet<>();
|
||||
|
||||
// 토픽별 파티션 추가 (설계서상 각 토픽은 3개 파티션)
|
||||
for (int i = 0; i < 3; i++) {
|
||||
partitions.add(new TopicPartition(EVENT_CREATED_TOPIC, i));
|
||||
partitions.add(new TopicPartition(PARTICIPANT_REGISTERED_TOPIC, i));
|
||||
partitions.add(new TopicPartition(DISTRIBUTION_COMPLETED_TOPIC, i));
|
||||
}
|
||||
|
||||
// Consumer Group Offset 삭제
|
||||
DeleteConsumerGroupOffsetsResult result = adminClient.deleteConsumerGroupOffsets(
|
||||
CONSUMER_GROUP_ID,
|
||||
partitions
|
||||
);
|
||||
|
||||
// 완료 대기 (최대 10초)
|
||||
result.all().get(10, TimeUnit.SECONDS);
|
||||
|
||||
log.info("✅ Kafka Consumer Offset 리셋 완료!");
|
||||
log.info(" → 다음 시작 시 처음부터(earliest) 메시지를 읽습니다.");
|
||||
|
||||
} catch (Exception e) {
|
||||
// Offset 리셋 실패는 치명적이지 않으므로 경고만 출력
|
||||
log.warn("⚠️ Kafka Consumer Offset 리셋 실패 (무시 가능): {}", e.getMessage());
|
||||
log.warn(" → 수동으로 Consumer Group ID를 변경하거나, Kafka 도구로 offset을 삭제하세요.");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* EventCreated 이벤트 발행
|
||||
*/
|
||||
private void publishEventCreatedEvents() throws Exception {
|
||||
// 이벤트 1: 신년맞이 할인 이벤트 (진행중, 높은 성과)
|
||||
// 이벤트 1: 신년맞이 할인 이벤트 (진행중, 높은 성과 - ROI 200%)
|
||||
EventCreatedEvent event1 = EventCreatedEvent.builder()
|
||||
.eventId("1")
|
||||
.eventTitle("신년맞이 20% 할인 이벤트")
|
||||
.storeId("store_001")
|
||||
.totalInvestment(new BigDecimal("5000000"))
|
||||
.expectedRevenue(new BigDecimal("15000000")) // 투자 대비 3배 수익
|
||||
.status("ACTIVE")
|
||||
.build();
|
||||
publishEvent(EVENT_CREATED_TOPIC, event1);
|
||||
|
||||
// 이벤트 2: 설날 특가 이벤트 (진행중, 중간 성과)
|
||||
// 이벤트 2: 설날 특가 이벤트 (진행중, 중간 성과 - ROI 100%)
|
||||
EventCreatedEvent event2 = EventCreatedEvent.builder()
|
||||
.eventId("2")
|
||||
.eventTitle("설날 특가 선물세트 이벤트")
|
||||
.storeId("store_001")
|
||||
.totalInvestment(new BigDecimal("3500000"))
|
||||
.expectedRevenue(new BigDecimal("7000000")) // 투자 대비 2배 수익
|
||||
.status("ACTIVE")
|
||||
.build();
|
||||
publishEvent(EVENT_CREATED_TOPIC, event2);
|
||||
|
||||
// 이벤트 3: 겨울 신메뉴 런칭 이벤트 (종료, 저조한 성과)
|
||||
// 이벤트 3: 겨울 신메뉴 런칭 이벤트 (종료, 저조한 성과 - ROI 50%)
|
||||
EventCreatedEvent event3 = EventCreatedEvent.builder()
|
||||
.eventId("3")
|
||||
.eventTitle("겨울 신메뉴 런칭 이벤트")
|
||||
.storeId("store_001")
|
||||
.totalInvestment(new BigDecimal("2000000"))
|
||||
.expectedRevenue(new BigDecimal("3000000")) // 투자 대비 1.5배 수익
|
||||
.status("COMPLETED")
|
||||
.build();
|
||||
publishEvent(EVENT_CREATED_TOPIC, event3);
|
||||
@@ -208,42 +263,63 @@ public class SampleDataLoader implements ApplicationRunner {
|
||||
{1500, 3000, 1000, 500} // 이벤트3
|
||||
};
|
||||
|
||||
// 각 이벤트의 총 투자 금액
|
||||
BigDecimal[] totalInvestments = {
|
||||
new BigDecimal("5000000"), // 이벤트1: 500만원
|
||||
new BigDecimal("3500000"), // 이벤트2: 350만원
|
||||
new BigDecimal("2000000") // 이벤트3: 200만원
|
||||
};
|
||||
|
||||
// 채널 배포는 총 투자의 50%만 사용 (나머지는 경품/콘텐츠/운영비용)
|
||||
double channelBudgetRatio = 0.50;
|
||||
|
||||
// 채널별 비용 비율 (채널 예산 내에서: 우리동네TV 30%, 지니TV 30%, 링고비즈 25%, SNS 15%)
|
||||
double[] costRatios = {0.30, 0.30, 0.25, 0.15};
|
||||
|
||||
for (int i = 0; i < eventIds.length; i++) {
|
||||
String eventId = eventIds[i];
|
||||
BigDecimal totalInvestment = totalInvestments[i];
|
||||
|
||||
// 채널 배포 예산: 총 투자의 50%
|
||||
BigDecimal channelBudget = totalInvestment.multiply(BigDecimal.valueOf(channelBudgetRatio));
|
||||
|
||||
// 4개 채널을 배열로 구성
|
||||
List<DistributionCompletedEvent.ChannelDistribution> channels = new ArrayList<>();
|
||||
|
||||
// 1. 우리동네TV (TV)
|
||||
// 1. 우리동네TV (TV) - 채널 예산의 30%
|
||||
channels.add(DistributionCompletedEvent.ChannelDistribution.builder()
|
||||
.channel("우리동네TV")
|
||||
.channelType("TV")
|
||||
.status("SUCCESS")
|
||||
.expectedViews(expectedViews[i][0])
|
||||
.distributionCost(channelBudget.multiply(BigDecimal.valueOf(costRatios[0])))
|
||||
.build());
|
||||
|
||||
// 2. 지니TV (TV)
|
||||
// 2. 지니TV (TV) - 채널 예산의 30%
|
||||
channels.add(DistributionCompletedEvent.ChannelDistribution.builder()
|
||||
.channel("지니TV")
|
||||
.channelType("TV")
|
||||
.status("SUCCESS")
|
||||
.expectedViews(expectedViews[i][1])
|
||||
.distributionCost(channelBudget.multiply(BigDecimal.valueOf(costRatios[1])))
|
||||
.build());
|
||||
|
||||
// 3. 링고비즈 (CALL)
|
||||
// 3. 링고비즈 (CALL) - 채널 예산의 25%
|
||||
channels.add(DistributionCompletedEvent.ChannelDistribution.builder()
|
||||
.channel("링고비즈")
|
||||
.channelType("CALL")
|
||||
.status("SUCCESS")
|
||||
.expectedViews(expectedViews[i][2])
|
||||
.distributionCost(channelBudget.multiply(BigDecimal.valueOf(costRatios[2])))
|
||||
.build());
|
||||
|
||||
// 4. SNS (SNS)
|
||||
// 4. SNS (SNS) - 채널 예산의 15%
|
||||
channels.add(DistributionCompletedEvent.ChannelDistribution.builder()
|
||||
.channel("SNS")
|
||||
.channelType("SNS")
|
||||
.status("SUCCESS")
|
||||
.expectedViews(expectedViews[i][3])
|
||||
.distributionCost(channelBudget.multiply(BigDecimal.valueOf(costRatios[3])))
|
||||
.build());
|
||||
|
||||
// 이벤트 발행 (채널 배열 포함)
|
||||
@@ -261,22 +337,53 @@ public class SampleDataLoader implements ApplicationRunner {
|
||||
|
||||
/**
|
||||
* ParticipantRegistered 이벤트 발행
|
||||
*
|
||||
* 현실적인 참여 패턴 반영:
|
||||
* - 총 120명의 고유 참여자 풀 생성
|
||||
* - 일부 참여자는 여러 이벤트에 중복 참여
|
||||
* - 이벤트1: 100명 (user001~user100)
|
||||
* - 이벤트2: 50명 (user051~user100) → 50명이 이벤트1과 중복
|
||||
* - 이벤트3: 30명 (user071~user100) → 30명이 이전 이벤트들과 중복
|
||||
*/
|
||||
private void publishParticipantRegisteredEvents() throws Exception {
|
||||
String[] eventIds = {"1", "2", "3"};
|
||||
int[] totalParticipants = {100, 50, 30}; // MVP 테스트용 샘플 데이터 (총 180명)
|
||||
String[] channels = {"우리동네TV", "지니TV", "링고비즈", "SNS"};
|
||||
|
||||
// 이벤트별 참여자 범위 (중복 참여 반영)
|
||||
int[][] participantRanges = {
|
||||
{1, 100}, // 이벤트1: user001~user100 (100명)
|
||||
{51, 100}, // 이벤트2: user051~user100 (50명, 이벤트1과 50명 중복)
|
||||
{71, 100} // 이벤트3: user071~user100 (30명, 모두 중복)
|
||||
};
|
||||
|
||||
int totalPublished = 0;
|
||||
|
||||
for (int i = 0; i < eventIds.length; i++) {
|
||||
String eventId = eventIds[i];
|
||||
int participants = totalParticipants[i];
|
||||
int startUser = participantRanges[i][0];
|
||||
int endUser = participantRanges[i][1];
|
||||
int eventParticipants = endUser - startUser + 1;
|
||||
|
||||
// 각 이벤트에 대해 참여자 수만큼 ParticipantRegistered 이벤트 발행
|
||||
for (int j = 0; j < participants; j++) {
|
||||
String participantId = UUID.randomUUID().toString();
|
||||
String channel = channels[j % channels.length]; // 채널 순환 배정
|
||||
log.info("이벤트 {} 참여자 발행 시작: user{:03d}~user{:03d} ({}명)",
|
||||
eventId, startUser, endUser, eventParticipants);
|
||||
|
||||
// 각 참여자에 대해 ParticipantRegistered 이벤트 발행
|
||||
for (int userId = startUser; userId <= endUser; userId++) {
|
||||
String participantId = String.format("user%03d", userId); // user001, user002, ...
|
||||
|
||||
// 채널별 가중치 기반 랜덤 배정
|
||||
// SNS: 45%, 우리동네TV: 25%, 지니TV: 20%, 링고비즈: 10%
|
||||
int randomValue = random.nextInt(100);
|
||||
String channel;
|
||||
if (randomValue < 45) {
|
||||
channel = "SNS"; // 0~44: 45%
|
||||
} else if (randomValue < 70) {
|
||||
channel = "우리동네TV"; // 45~69: 25%
|
||||
} else if (randomValue < 90) {
|
||||
channel = "지니TV"; // 70~89: 20%
|
||||
} else {
|
||||
channel = "링고비즈"; // 90~99: 10%
|
||||
}
|
||||
|
||||
ParticipantRegisteredEvent event = ParticipantRegisteredEvent.builder()
|
||||
.eventId(eventId)
|
||||
@@ -288,19 +395,38 @@ public class SampleDataLoader implements ApplicationRunner {
|
||||
totalPublished++;
|
||||
|
||||
// 동시성 충돌 방지: 10개마다 100ms 대기
|
||||
if ((j + 1) % 10 == 0) {
|
||||
if (totalPublished % 10 == 0) {
|
||||
Thread.sleep(100);
|
||||
}
|
||||
}
|
||||
|
||||
log.info("✅ 이벤트 {} 참여자 발행 완료: {}명", eventId, eventParticipants);
|
||||
}
|
||||
|
||||
log.info("========================================");
|
||||
log.info("✅ ParticipantRegistered 이벤트 {}건 발행 완료", totalPublished);
|
||||
log.info("📊 참여 패턴:");
|
||||
log.info(" - 총 고유 참여자: 100명 (user001~user100)");
|
||||
log.info(" - 이벤트1 참여: 100명");
|
||||
log.info(" - 이벤트2 참여: 50명 (이벤트1과 50명 중복)");
|
||||
log.info(" - 이벤트3 참여: 30명 (이벤트1,2와 모두 중복)");
|
||||
log.info(" - 3개 이벤트 모두 참여: 30명");
|
||||
log.info(" - 2개 이벤트 참여: 20명");
|
||||
log.info(" - 1개 이벤트만 참여: 50명");
|
||||
log.info("📺 채널별 참여 비율 (가중치):");
|
||||
log.info(" - SNS: 45% (가장 높음)");
|
||||
log.info(" - 우리동네TV: 25%");
|
||||
log.info(" - 지니TV: 20%");
|
||||
log.info(" - 링고비즈: 10%");
|
||||
log.info("========================================");
|
||||
}
|
||||
|
||||
/**
|
||||
* TimelineData 생성 (시간대별 샘플 데이터)
|
||||
*
|
||||
* - 각 이벤트마다 30일 치 daily 데이터 생성
|
||||
* - 각 이벤트마다 30일 × 24시간 = 720시간 치 hourly 데이터 생성
|
||||
* - interval=hourly: 시간별 표시 (최근 7일 적합)
|
||||
* - interval=daily: 일별 자동 집계 (30일 전체)
|
||||
* - 참여자 수, 조회수, 참여행동, 전환수, 누적 참여자 수
|
||||
*/
|
||||
private void createTimelineData() {
|
||||
@@ -308,52 +434,63 @@ public class SampleDataLoader implements ApplicationRunner {
|
||||
|
||||
String[] eventIds = {"1", "2", "3"};
|
||||
|
||||
// 각 이벤트별 기준 참여자 수 (이벤트 성과에 따라 다름)
|
||||
int[] baseParticipants = {20, 12, 5}; // 이벤트1(높음), 이벤트2(중간), 이벤트3(낮음)
|
||||
// 각 이벤트별 시간당 기준 참여자 수 (이벤트 성과에 따라 다름)
|
||||
int[] baseParticipantsPerHour = {4, 2, 1}; // 이벤트1(높음), 이벤트2(중간), 이벤트3(낮음)
|
||||
|
||||
for (int eventIndex = 0; eventIndex < eventIds.length; eventIndex++) {
|
||||
String eventId = eventIds[eventIndex];
|
||||
int baseParticipant = baseParticipants[eventIndex];
|
||||
int baseParticipant = baseParticipantsPerHour[eventIndex];
|
||||
int cumulativeParticipants = 0;
|
||||
|
||||
// 30일 치 데이터 생성 (2024-09-24부터)
|
||||
java.time.LocalDateTime startDate = java.time.LocalDateTime.of(2024, 9, 24, 0, 0);
|
||||
// 이벤트 ID에서 날짜 파싱 (evt_2025012301 → 2025-01-23)
|
||||
String dateStr = eventId.substring(4); // "2025012301"
|
||||
int year = Integer.parseInt(dateStr.substring(0, 4)); // 2025
|
||||
int month = Integer.parseInt(dateStr.substring(4, 6)); // 01
|
||||
int day = Integer.parseInt(dateStr.substring(6, 8)); // 23
|
||||
|
||||
for (int day = 0; day < 30; day++) {
|
||||
java.time.LocalDateTime timestamp = startDate.plusDays(day);
|
||||
// 이벤트 시작일부터 30일 치 hourly 데이터 생성
|
||||
java.time.LocalDateTime startDate = java.time.LocalDateTime.of(year, month, day, 0, 0);
|
||||
|
||||
// 랜덤한 참여자 수 생성 (기준값 ± 50%)
|
||||
int dailyParticipants = baseParticipant + random.nextInt(baseParticipant + 1);
|
||||
cumulativeParticipants += dailyParticipants;
|
||||
for (int dayOffset = 0; dayOffset < 30; dayOffset++) {
|
||||
for (int hour = 0; hour < 24; hour++) {
|
||||
java.time.LocalDateTime timestamp = startDate.plusDays(dayOffset).plusHours(hour);
|
||||
|
||||
// 조회수는 참여자의 3~5배
|
||||
int dailyViews = dailyParticipants * (3 + random.nextInt(3));
|
||||
// 시간대별 참여자 수 변화 (낮 시간대 12~20시에 더 많음)
|
||||
int hourMultiplier = (hour >= 12 && hour <= 20) ? 2 : 1;
|
||||
int hourlyParticipants = (baseParticipant * hourMultiplier) + random.nextInt(baseParticipant + 1);
|
||||
|
||||
// 참여행동은 참여자의 1~2배
|
||||
int dailyEngagement = dailyParticipants * (1 + random.nextInt(2));
|
||||
cumulativeParticipants += hourlyParticipants;
|
||||
|
||||
// 전환수는 참여자의 50~80%
|
||||
int dailyConversions = (int) (dailyParticipants * (0.5 + random.nextDouble() * 0.3));
|
||||
// 조회수는 참여자의 3~5배
|
||||
int hourlyViews = hourlyParticipants * (3 + random.nextInt(3));
|
||||
|
||||
// TimelineData 생성
|
||||
com.kt.event.analytics.entity.TimelineData timelineData =
|
||||
com.kt.event.analytics.entity.TimelineData.builder()
|
||||
.eventId(eventId)
|
||||
.timestamp(timestamp)
|
||||
.participants(dailyParticipants)
|
||||
.views(dailyViews)
|
||||
.engagement(dailyEngagement)
|
||||
.conversions(dailyConversions)
|
||||
.cumulativeParticipants(cumulativeParticipants)
|
||||
.build();
|
||||
// 참여행동은 참여자의 1~2배
|
||||
int hourlyEngagement = hourlyParticipants * (1 + random.nextInt(2));
|
||||
|
||||
timelineDataRepository.save(timelineData);
|
||||
// 전환수는 참여자의 50~80%
|
||||
int hourlyConversions = (int) (hourlyParticipants * (0.5 + random.nextDouble() * 0.3));
|
||||
|
||||
// TimelineData 생성
|
||||
com.kt.event.analytics.entity.TimelineData timelineData =
|
||||
com.kt.event.analytics.entity.TimelineData.builder()
|
||||
.eventId(eventId)
|
||||
.timestamp(timestamp)
|
||||
.participants(hourlyParticipants)
|
||||
.views(hourlyViews)
|
||||
.engagement(hourlyEngagement)
|
||||
.conversions(hourlyConversions)
|
||||
.cumulativeParticipants(cumulativeParticipants)
|
||||
.build();
|
||||
|
||||
timelineDataRepository.save(timelineData);
|
||||
}
|
||||
}
|
||||
|
||||
log.info("✅ TimelineData 생성 완료: eventId={}, 30일 데이터", eventId);
|
||||
log.info("✅ TimelineData 생성 완료: eventId={}, 시작일={}-{:02d}-{:02d}, 30일 × 24시간 = 720건",
|
||||
eventId, year, month, day);
|
||||
}
|
||||
|
||||
log.info("✅ 전체 TimelineData 생성 완료: 3개 이벤트 × 30일 = 90건");
|
||||
log.info("✅ 전체 TimelineData 생성 완료: 3개 이벤트 × 30일 × 24시간 = 2,160건");
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
+5
-17
@@ -31,31 +31,19 @@ public class AnalyticsDashboardController {
|
||||
/**
|
||||
* 성과 대시보드 조회
|
||||
*
|
||||
* @param eventId 이벤트 ID
|
||||
* @param startDate 조회 시작 날짜
|
||||
* @param endDate 조회 종료 날짜
|
||||
* @param refresh 캐시 갱신 여부
|
||||
* @return 성과 대시보드
|
||||
* @param eventId 이벤트 ID
|
||||
* @param refresh 캐시 갱신 여부
|
||||
* @return 성과 대시보드 (이벤트 시작일 ~ 현재까지)
|
||||
*/
|
||||
@Operation(
|
||||
summary = "성과 대시보드 조회",
|
||||
description = "이벤트의 전체 성과를 통합하여 조회합니다."
|
||||
description = "이벤트의 전체 성과를 통합하여 조회합니다. (이벤트 시작일 ~ 현재까지)"
|
||||
)
|
||||
@GetMapping("/{eventId}/analytics")
|
||||
public ResponseEntity<ApiResponse<AnalyticsDashboardResponse>> getEventAnalytics(
|
||||
@Parameter(description = "이벤트 ID", required = true)
|
||||
@PathVariable String eventId,
|
||||
|
||||
@Parameter(description = "조회 시작 날짜 (ISO 8601 format)")
|
||||
@RequestParam(required = false)
|
||||
@DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
|
||||
LocalDateTime startDate,
|
||||
|
||||
@Parameter(description = "조회 종료 날짜 (ISO 8601 format)")
|
||||
@RequestParam(required = false)
|
||||
@DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
|
||||
LocalDateTime endDate,
|
||||
|
||||
@Parameter(description = "캐시 갱신 여부 (true인 경우 외부 API 호출)")
|
||||
@RequestParam(required = false, defaultValue = "false")
|
||||
Boolean refresh
|
||||
@@ -63,7 +51,7 @@ public class AnalyticsDashboardController {
|
||||
log.info("성과 대시보드 조회 API 호출: eventId={}, refresh={}", eventId, refresh);
|
||||
|
||||
AnalyticsDashboardResponse response = analyticsService.getDashboardData(
|
||||
eventId, startDate, endDate, refresh
|
||||
eventId, refresh
|
||||
);
|
||||
|
||||
return ResponseEntity.ok(ApiResponse.success(response));
|
||||
|
||||
+75
@@ -0,0 +1,75 @@
|
||||
package com.kt.event.analytics.controller;
|
||||
|
||||
import com.kt.event.analytics.config.SampleDataLoader;
|
||||
import com.kt.event.common.dto.ApiResponse;
|
||||
import io.swagger.v3.oas.annotations.Operation;
|
||||
import io.swagger.v3.oas.annotations.tags.Tag;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.boot.ApplicationArguments;
|
||||
import org.springframework.http.ResponseEntity;
|
||||
import org.springframework.web.bind.annotation.PostMapping;
|
||||
import org.springframework.web.bind.annotation.RequestMapping;
|
||||
import org.springframework.web.bind.annotation.RestController;
|
||||
|
||||
/**
|
||||
* 디버그 컨트롤러
|
||||
*
|
||||
* ⚠️ 개발/테스트 전용
|
||||
*/
|
||||
@Tag(name = "Debug", description = "디버그 API (개발/테스트 전용)")
|
||||
@Slf4j
|
||||
@RestController
|
||||
@RequestMapping("/api/debug")
|
||||
@RequiredArgsConstructor
|
||||
public class DebugController {
|
||||
|
||||
private final SampleDataLoader sampleDataLoader;
|
||||
|
||||
/**
|
||||
* 샘플 데이터 수동 생성
|
||||
*/
|
||||
@Operation(
|
||||
summary = "샘플 데이터 수동 생성",
|
||||
description = "SampleDataLoader를 수동으로 실행하여 샘플 데이터를 생성합니다."
|
||||
)
|
||||
@PostMapping("/reload-sample-data")
|
||||
public ResponseEntity<ApiResponse<String>> reloadSampleData() {
|
||||
try {
|
||||
log.info("🔧 수동으로 샘플 데이터 생성 요청");
|
||||
|
||||
// SampleDataLoader 실행
|
||||
sampleDataLoader.run(new ApplicationArguments() {
|
||||
@Override
|
||||
public String[] getSourceArgs() {
|
||||
return new String[0];
|
||||
}
|
||||
|
||||
@Override
|
||||
public java.util.Set<String> getOptionNames() {
|
||||
return java.util.Collections.emptySet();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean containsOption(String name) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public java.util.List<String> getOptionValues(String name) {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public java.util.List<String> getNonOptionArgs() {
|
||||
return java.util.Collections.emptyList();
|
||||
}
|
||||
});
|
||||
|
||||
return ResponseEntity.ok(ApiResponse.success("샘플 데이터 생성 완료"));
|
||||
} catch (Exception e) {
|
||||
log.error("❌ 샘플 데이터 생성 실패", e);
|
||||
return ResponseEntity.ok(ApiResponse.success("샘플 데이터 생성 실패: " + e.getMessage()));
|
||||
}
|
||||
}
|
||||
}
|
||||
+6
-18
@@ -33,16 +33,14 @@ public class TimelineAnalyticsController {
|
||||
/**
|
||||
* 시간대별 참여 추이
|
||||
*
|
||||
* @param eventId 이벤트 ID
|
||||
* @param interval 시간 간격 단위
|
||||
* @param startDate 조회 시작 날짜
|
||||
* @param endDate 조회 종료 날짜
|
||||
* @param metrics 조회할 지표 목록
|
||||
* @return 시간대별 참여 추이
|
||||
* @param eventId 이벤트 ID
|
||||
* @param interval 시간 간격 단위
|
||||
* @param metrics 조회할 지표 목록
|
||||
* @return 시간대별 참여 추이 (이벤트 시작일 ~ 현재까지)
|
||||
*/
|
||||
@Operation(
|
||||
summary = "시간대별 참여 추이",
|
||||
description = "이벤트 기간 동안의 시간대별 참여 추이를 분석합니다."
|
||||
description = "이벤트 기간 동안의 시간대별 참여 추이를 분석합니다. (이벤트 시작일 ~ 현재까지)"
|
||||
)
|
||||
@GetMapping("/{eventId}/analytics/timeline")
|
||||
public ResponseEntity<ApiResponse<TimelineAnalyticsResponse>> getTimelineAnalytics(
|
||||
@@ -53,16 +51,6 @@ public class TimelineAnalyticsController {
|
||||
@RequestParam(required = false, defaultValue = "daily")
|
||||
String interval,
|
||||
|
||||
@Parameter(description = "조회 시작 날짜 (ISO 8601 format)")
|
||||
@RequestParam(required = false)
|
||||
@DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
|
||||
LocalDateTime startDate,
|
||||
|
||||
@Parameter(description = "조회 종료 날짜 (ISO 8601 format)")
|
||||
@RequestParam(required = false)
|
||||
@DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
|
||||
LocalDateTime endDate,
|
||||
|
||||
@Parameter(description = "조회할 지표 목록 (쉼표로 구분)")
|
||||
@RequestParam(required = false)
|
||||
String metrics
|
||||
@@ -74,7 +62,7 @@ public class TimelineAnalyticsController {
|
||||
: null;
|
||||
|
||||
TimelineAnalyticsResponse response = timelineAnalyticsService.getTimelineAnalytics(
|
||||
eventId, interval, startDate, endDate, metricList
|
||||
eventId, interval, metricList
|
||||
);
|
||||
|
||||
return ResponseEntity.ok(ApiResponse.success(response));
|
||||
|
||||
+59
@@ -0,0 +1,59 @@
|
||||
package com.kt.event.analytics.controller;
|
||||
|
||||
import com.kt.event.analytics.dto.response.UserAnalyticsDashboardResponse;
|
||||
import com.kt.event.analytics.service.UserAnalyticsService;
|
||||
import com.kt.event.common.dto.ApiResponse;
|
||||
import io.swagger.v3.oas.annotations.Operation;
|
||||
import io.swagger.v3.oas.annotations.Parameter;
|
||||
import io.swagger.v3.oas.annotations.tags.Tag;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.format.annotation.DateTimeFormat;
|
||||
import org.springframework.http.ResponseEntity;
|
||||
import org.springframework.web.bind.annotation.*;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
|
||||
/**
|
||||
* User Analytics Dashboard Controller
|
||||
*
|
||||
* 사용자 전체 이벤트 통합 성과 대시보드 API
|
||||
*/
|
||||
@Tag(name = "User Analytics", description = "사용자 전체 이벤트 통합 성과 분석 API")
|
||||
@Slf4j
|
||||
@RestController
|
||||
@RequestMapping("/api/v1/users")
|
||||
@RequiredArgsConstructor
|
||||
public class UserAnalyticsDashboardController {
|
||||
|
||||
private final UserAnalyticsService userAnalyticsService;
|
||||
|
||||
/**
|
||||
* 사용자 전체 성과 대시보드 조회
|
||||
*
|
||||
* @param userId 사용자 ID
|
||||
* @param refresh 캐시 갱신 여부
|
||||
* @return 전체 통합 성과 대시보드 (userId 기반 전체 이벤트 조회)
|
||||
*/
|
||||
@Operation(
|
||||
summary = "사용자 전체 성과 대시보드 조회",
|
||||
description = "사용자의 모든 이벤트 성과를 통합하여 조회합니다. (userId 기반 전체 이벤트 조회)"
|
||||
)
|
||||
@GetMapping("/{userId}/analytics")
|
||||
public ResponseEntity<ApiResponse<UserAnalyticsDashboardResponse>> getUserAnalytics(
|
||||
@Parameter(description = "사용자 ID", required = true)
|
||||
@PathVariable String userId,
|
||||
|
||||
@Parameter(description = "캐시 갱신 여부")
|
||||
@RequestParam(required = false, defaultValue = "false")
|
||||
Boolean refresh
|
||||
) {
|
||||
log.info("사용자 전체 성과 대시보드 조회 API 호출: userId={}, refresh={}", userId, refresh);
|
||||
|
||||
UserAnalyticsDashboardResponse response = userAnalyticsService.getUserDashboardData(
|
||||
userId, refresh
|
||||
);
|
||||
|
||||
return ResponseEntity.ok(ApiResponse.success(response));
|
||||
}
|
||||
}
|
||||
+60
@@ -0,0 +1,60 @@
|
||||
package com.kt.event.analytics.controller;
|
||||
|
||||
import com.kt.event.analytics.dto.response.UserChannelAnalyticsResponse;
|
||||
import com.kt.event.analytics.service.UserChannelAnalyticsService;
|
||||
import com.kt.event.common.dto.ApiResponse;
|
||||
import io.swagger.v3.oas.annotations.Operation;
|
||||
import io.swagger.v3.oas.annotations.Parameter;
|
||||
import io.swagger.v3.oas.annotations.tags.Tag;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.format.annotation.DateTimeFormat;
|
||||
import org.springframework.http.ResponseEntity;
|
||||
import org.springframework.web.bind.annotation.*;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* User Channel Analytics Controller
|
||||
*/
|
||||
@Tag(name = "User Channels", description = "사용자 전체 이벤트 채널별 성과 분석 API")
|
||||
@Slf4j
|
||||
@RestController
|
||||
@RequestMapping("/api/v1/users")
|
||||
@RequiredArgsConstructor
|
||||
public class UserChannelAnalyticsController {
|
||||
|
||||
private final UserChannelAnalyticsService userChannelAnalyticsService;
|
||||
|
||||
@Operation(
|
||||
summary = "사용자 전체 채널별 성과 분석",
|
||||
description = "사용자의 모든 이벤트 채널 성과를 통합하여 분석합니다. (전체 채널 무조건 표시)"
|
||||
)
|
||||
@GetMapping("/{userId}/analytics/channels")
|
||||
public ResponseEntity<ApiResponse<UserChannelAnalyticsResponse>> getUserChannelAnalytics(
|
||||
@Parameter(description = "사용자 ID", required = true)
|
||||
@PathVariable String userId,
|
||||
|
||||
@Parameter(description = "정렬 기준")
|
||||
@RequestParam(required = false, defaultValue = "participants")
|
||||
String sortBy,
|
||||
|
||||
@Parameter(description = "정렬 순서")
|
||||
@RequestParam(required = false, defaultValue = "desc")
|
||||
String order,
|
||||
|
||||
@Parameter(description = "캐시 갱신 여부")
|
||||
@RequestParam(required = false, defaultValue = "false")
|
||||
Boolean refresh
|
||||
) {
|
||||
log.info("사용자 채널 분석 API 호출: userId={}, sortBy={}", userId, sortBy);
|
||||
|
||||
UserChannelAnalyticsResponse response = userChannelAnalyticsService.getUserChannelAnalytics(
|
||||
userId, sortBy, order, refresh
|
||||
);
|
||||
|
||||
return ResponseEntity.ok(ApiResponse.success(response));
|
||||
}
|
||||
}
|
||||
+54
@@ -0,0 +1,54 @@
|
||||
package com.kt.event.analytics.controller;
|
||||
|
||||
import com.kt.event.analytics.dto.response.UserRoiAnalyticsResponse;
|
||||
import com.kt.event.analytics.service.UserRoiAnalyticsService;
|
||||
import com.kt.event.common.dto.ApiResponse;
|
||||
import io.swagger.v3.oas.annotations.Operation;
|
||||
import io.swagger.v3.oas.annotations.Parameter;
|
||||
import io.swagger.v3.oas.annotations.tags.Tag;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.format.annotation.DateTimeFormat;
|
||||
import org.springframework.http.ResponseEntity;
|
||||
import org.springframework.web.bind.annotation.*;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
|
||||
/**
|
||||
* User ROI Analytics Controller
|
||||
*/
|
||||
@Tag(name = "User ROI", description = "사용자 전체 이벤트 ROI 분석 API")
|
||||
@Slf4j
|
||||
@RestController
|
||||
@RequestMapping("/api/v1/users")
|
||||
@RequiredArgsConstructor
|
||||
public class UserRoiAnalyticsController {
|
||||
|
||||
private final UserRoiAnalyticsService userRoiAnalyticsService;
|
||||
|
||||
@Operation(
|
||||
summary = "사용자 전체 ROI 상세 분석",
|
||||
description = "사용자의 모든 이벤트 ROI를 통합하여 분석합니다. (userId 기반 전체 이벤트 조회)"
|
||||
)
|
||||
@GetMapping("/{userId}/analytics/roi")
|
||||
public ResponseEntity<ApiResponse<UserRoiAnalyticsResponse>> getUserRoiAnalytics(
|
||||
@Parameter(description = "사용자 ID", required = true)
|
||||
@PathVariable String userId,
|
||||
|
||||
@Parameter(description = "예상 수익 포함 여부")
|
||||
@RequestParam(required = false, defaultValue = "true")
|
||||
Boolean includeProjection,
|
||||
|
||||
@Parameter(description = "캐시 갱신 여부")
|
||||
@RequestParam(required = false, defaultValue = "false")
|
||||
Boolean refresh
|
||||
) {
|
||||
log.info("사용자 ROI 분석 API 호출: userId={}, includeProjection={}", userId, includeProjection);
|
||||
|
||||
UserRoiAnalyticsResponse response = userRoiAnalyticsService.getUserRoiAnalytics(
|
||||
userId, includeProjection, refresh
|
||||
);
|
||||
|
||||
return ResponseEntity.ok(ApiResponse.success(response));
|
||||
}
|
||||
}
|
||||
+64
@@ -0,0 +1,64 @@
|
||||
package com.kt.event.analytics.controller;
|
||||
|
||||
import com.kt.event.analytics.dto.response.UserTimelineAnalyticsResponse;
|
||||
import com.kt.event.analytics.service.UserTimelineAnalyticsService;
|
||||
import com.kt.event.common.dto.ApiResponse;
|
||||
import io.swagger.v3.oas.annotations.Operation;
|
||||
import io.swagger.v3.oas.annotations.Parameter;
|
||||
import io.swagger.v3.oas.annotations.tags.Tag;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.format.annotation.DateTimeFormat;
|
||||
import org.springframework.http.ResponseEntity;
|
||||
import org.springframework.web.bind.annotation.*;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* User Timeline Analytics Controller
|
||||
*/
|
||||
@Tag(name = "User Timeline", description = "사용자 전체 이벤트 시간대별 분석 API")
|
||||
@Slf4j
|
||||
@RestController
|
||||
@RequestMapping("/api/v1/users")
|
||||
@RequiredArgsConstructor
|
||||
public class UserTimelineAnalyticsController {
|
||||
|
||||
private final UserTimelineAnalyticsService userTimelineAnalyticsService;
|
||||
|
||||
@Operation(
|
||||
summary = "사용자 전체 시간대별 참여 추이",
|
||||
description = "사용자의 모든 이벤트 시간대별 데이터를 통합하여 분석합니다. (userId 기반 전체 이벤트 조회)"
|
||||
)
|
||||
@GetMapping("/{userId}/analytics/timeline")
|
||||
public ResponseEntity<ApiResponse<UserTimelineAnalyticsResponse>> getUserTimelineAnalytics(
|
||||
@Parameter(description = "사용자 ID", required = true)
|
||||
@PathVariable String userId,
|
||||
|
||||
@Parameter(description = "시간 간격 단위 (hourly, daily, weekly, monthly)")
|
||||
@RequestParam(required = false, defaultValue = "daily")
|
||||
String interval,
|
||||
|
||||
@Parameter(description = "조회할 지표 목록 (쉼표로 구분)")
|
||||
@RequestParam(required = false)
|
||||
String metrics,
|
||||
|
||||
@Parameter(description = "캐시 갱신 여부")
|
||||
@RequestParam(required = false, defaultValue = "false")
|
||||
Boolean refresh
|
||||
) {
|
||||
log.info("사용자 타임라인 분석 API 호출: userId={}, interval={}", userId, interval);
|
||||
|
||||
List<String> metricList = metrics != null && !metrics.isBlank()
|
||||
? Arrays.asList(metrics.split(","))
|
||||
: null;
|
||||
|
||||
UserTimelineAnalyticsResponse response = userTimelineAnalyticsService.getUserTimelineAnalytics(
|
||||
userId, interval, metricList, refresh
|
||||
);
|
||||
|
||||
return ResponseEntity.ok(ApiResponse.success(response));
|
||||
}
|
||||
}
|
||||
+15
@@ -47,6 +47,21 @@ public class AnalyticsDashboardResponse {
|
||||
*/
|
||||
private RoiSummary roi;
|
||||
|
||||
/**
|
||||
* 투자 비용 상세
|
||||
*/
|
||||
private InvestmentDetails investment;
|
||||
|
||||
/**
|
||||
* 수익 상세
|
||||
*/
|
||||
private RevenueDetails revenue;
|
||||
|
||||
/**
|
||||
* 비용 효율성 분석
|
||||
*/
|
||||
private CostEfficiency costEfficiency;
|
||||
|
||||
/**
|
||||
* 마지막 업데이트 시간
|
||||
*/
|
||||
|
||||
+11
-1
@@ -17,7 +17,12 @@ public class AnalyticsSummary {
|
||||
/**
|
||||
* 총 참여자 수
|
||||
*/
|
||||
private Integer totalParticipants;
|
||||
private Integer participants;
|
||||
|
||||
/**
|
||||
* 참여자 증감 (이전 기간 대비)
|
||||
*/
|
||||
private Integer participantsDelta;
|
||||
|
||||
/**
|
||||
* 총 조회수
|
||||
@@ -44,6 +49,11 @@ public class AnalyticsSummary {
|
||||
*/
|
||||
private Integer averageEngagementTime;
|
||||
|
||||
/**
|
||||
* 목표 ROI (%)
|
||||
*/
|
||||
private Double targetRoi;
|
||||
|
||||
/**
|
||||
* SNS 반응 통계
|
||||
*/
|
||||
|
||||
+1
-1
@@ -17,7 +17,7 @@ public class ChannelSummary {
|
||||
/**
|
||||
* 채널명
|
||||
*/
|
||||
private String channelName;
|
||||
private String channel;
|
||||
|
||||
/**
|
||||
* 조회수
|
||||
|
||||
+10
@@ -33,6 +33,16 @@ public class InvestmentDetails {
|
||||
*/
|
||||
private BigDecimal operation;
|
||||
|
||||
/**
|
||||
* 경품 비용 (원)
|
||||
*/
|
||||
private BigDecimal prizeCost;
|
||||
|
||||
/**
|
||||
* 채널 비용 (원) - distribution과 동일한 값
|
||||
*/
|
||||
private BigDecimal channelCost;
|
||||
|
||||
/**
|
||||
* 총 투자 비용 (원)
|
||||
*/
|
||||
|
||||
+10
@@ -26,6 +26,16 @@ public class RevenueDetails {
|
||||
*/
|
||||
private BigDecimal expectedSales;
|
||||
|
||||
/**
|
||||
* 신규 고객 매출 (원)
|
||||
*/
|
||||
private BigDecimal newCustomerRevenue;
|
||||
|
||||
/**
|
||||
* 기존 고객 매출 (원)
|
||||
*/
|
||||
private BigDecimal existingCustomerRevenue;
|
||||
|
||||
/**
|
||||
* 브랜드 가치 향상 추정액 (원)
|
||||
*/
|
||||
|
||||
@@ -19,7 +19,7 @@ public class RoiSummary {
|
||||
/**
|
||||
* 총 투자 비용 (원)
|
||||
*/
|
||||
private BigDecimal totalInvestment;
|
||||
private BigDecimal totalCost;
|
||||
|
||||
/**
|
||||
* 예상 매출 증대 (원)
|
||||
|
||||
+87
@@ -0,0 +1,87 @@
|
||||
package com.kt.event.analytics.dto.response;
|
||||
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Builder;
|
||||
import lombok.Data;
|
||||
import lombok.NoArgsConstructor;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* 사용자 전체 이벤트 통합 대시보드 응답
|
||||
*
|
||||
* 사용자 ID 기반으로 모든 이벤트의 성과를 통합하여 제공
|
||||
*/
|
||||
@Data
|
||||
@Builder
|
||||
@NoArgsConstructor
|
||||
@AllArgsConstructor
|
||||
public class UserAnalyticsDashboardResponse {
|
||||
|
||||
/**
|
||||
* 사용자 ID
|
||||
*/
|
||||
private String userId;
|
||||
|
||||
/**
|
||||
* 조회 기간 정보
|
||||
*/
|
||||
private PeriodInfo period;
|
||||
|
||||
/**
|
||||
* 전체 이벤트 수
|
||||
*/
|
||||
private Integer totalEvents;
|
||||
|
||||
/**
|
||||
* 활성 이벤트 수
|
||||
*/
|
||||
private Integer activeEvents;
|
||||
|
||||
/**
|
||||
* 전체 성과 요약 (모든 이벤트 통합)
|
||||
*/
|
||||
private AnalyticsSummary overallSummary;
|
||||
|
||||
/**
|
||||
* 채널별 성과 요약 (모든 이벤트 통합)
|
||||
*/
|
||||
private List<ChannelSummary> channelPerformance;
|
||||
|
||||
/**
|
||||
* 전체 ROI 요약
|
||||
*/
|
||||
private RoiSummary overallRoi;
|
||||
|
||||
/**
|
||||
* 이벤트별 성과 목록 (간략)
|
||||
*/
|
||||
private List<EventPerformanceSummary> eventPerformances;
|
||||
|
||||
/**
|
||||
* 마지막 업데이트 시간
|
||||
*/
|
||||
private LocalDateTime lastUpdatedAt;
|
||||
|
||||
/**
|
||||
* 데이터 출처 (real-time, cached, fallback)
|
||||
*/
|
||||
private String dataSource;
|
||||
|
||||
/**
|
||||
* 이벤트별 성과 요약
|
||||
*/
|
||||
@Data
|
||||
@Builder
|
||||
@NoArgsConstructor
|
||||
@AllArgsConstructor
|
||||
public static class EventPerformanceSummary {
|
||||
private String eventId;
|
||||
private String eventTitle;
|
||||
private Integer participants;
|
||||
private Integer views;
|
||||
private Double roi;
|
||||
private String status;
|
||||
}
|
||||
}
|
||||
+56
@@ -0,0 +1,56 @@
|
||||
package com.kt.event.analytics.dto.response;
|
||||
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Builder;
|
||||
import lombok.Data;
|
||||
import lombok.NoArgsConstructor;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* 사용자 전체 이벤트의 채널별 성과 분석 응답
|
||||
*
|
||||
* 사용자 ID 기반으로 모든 이벤트의 채널 성과를 통합하여 제공
|
||||
*/
|
||||
@Data
|
||||
@Builder
|
||||
@NoArgsConstructor
|
||||
@AllArgsConstructor
|
||||
public class UserChannelAnalyticsResponse {
|
||||
|
||||
/**
|
||||
* 사용자 ID
|
||||
*/
|
||||
private String userId;
|
||||
|
||||
/**
|
||||
* 조회 기간 정보
|
||||
*/
|
||||
private PeriodInfo period;
|
||||
|
||||
/**
|
||||
* 전체 이벤트 수
|
||||
*/
|
||||
private Integer totalEvents;
|
||||
|
||||
/**
|
||||
* 채널별 통합 성과 목록
|
||||
*/
|
||||
private List<ChannelAnalytics> channels;
|
||||
|
||||
/**
|
||||
* 채널 간 비교 분석
|
||||
*/
|
||||
private ChannelComparison comparison;
|
||||
|
||||
/**
|
||||
* 마지막 업데이트 시간
|
||||
*/
|
||||
private LocalDateTime lastUpdatedAt;
|
||||
|
||||
/**
|
||||
* 데이터 출처
|
||||
*/
|
||||
private String dataSource;
|
||||
}
|
||||
+92
@@ -0,0 +1,92 @@
|
||||
package com.kt.event.analytics.dto.response;
|
||||
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Builder;
|
||||
import lombok.Data;
|
||||
import lombok.NoArgsConstructor;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* 사용자 전체 이벤트의 ROI 분석 응답
|
||||
*
|
||||
* 사용자 ID 기반으로 모든 이벤트의 ROI를 통합하여 제공
|
||||
*/
|
||||
@Data
|
||||
@Builder
|
||||
@NoArgsConstructor
|
||||
@AllArgsConstructor
|
||||
public class UserRoiAnalyticsResponse {
|
||||
|
||||
/**
|
||||
* 사용자 ID
|
||||
*/
|
||||
private String userId;
|
||||
|
||||
/**
|
||||
* 조회 기간 정보
|
||||
*/
|
||||
private PeriodInfo period;
|
||||
|
||||
/**
|
||||
* 전체 이벤트 수
|
||||
*/
|
||||
private Integer totalEvents;
|
||||
|
||||
/**
|
||||
* 전체 투자 정보 (모든 이벤트 합계)
|
||||
*/
|
||||
private InvestmentDetails overallInvestment;
|
||||
|
||||
/**
|
||||
* 전체 수익 정보 (모든 이벤트 합계)
|
||||
*/
|
||||
private RevenueDetails overallRevenue;
|
||||
|
||||
/**
|
||||
* 전체 ROI 계산 결과
|
||||
*/
|
||||
private RoiCalculation overallRoi;
|
||||
|
||||
/**
|
||||
* 비용 효율성 분석
|
||||
*/
|
||||
private CostEfficiency costEfficiency;
|
||||
|
||||
/**
|
||||
* 수익 예측 (포함 여부에 따라 nullable)
|
||||
*/
|
||||
private RevenueProjection projection;
|
||||
|
||||
/**
|
||||
* 이벤트별 ROI 목록
|
||||
*/
|
||||
private List<EventRoiSummary> eventRois;
|
||||
|
||||
/**
|
||||
* 마지막 업데이트 시간
|
||||
*/
|
||||
private LocalDateTime lastUpdatedAt;
|
||||
|
||||
/**
|
||||
* 데이터 출처
|
||||
*/
|
||||
private String dataSource;
|
||||
|
||||
/**
|
||||
* 이벤트별 ROI 요약
|
||||
*/
|
||||
@Data
|
||||
@Builder
|
||||
@NoArgsConstructor
|
||||
@AllArgsConstructor
|
||||
public static class EventRoiSummary {
|
||||
private String eventId;
|
||||
private String eventTitle;
|
||||
private Double totalInvestment;
|
||||
private Double expectedRevenue;
|
||||
private Double roi;
|
||||
private String status;
|
||||
}
|
||||
}
|
||||
+66
@@ -0,0 +1,66 @@
|
||||
package com.kt.event.analytics.dto.response;
|
||||
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Builder;
|
||||
import lombok.Data;
|
||||
import lombok.NoArgsConstructor;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* 사용자 전체 이벤트의 시간대별 분석 응답
|
||||
*
|
||||
* 사용자 ID 기반으로 모든 이벤트의 시간대별 데이터를 통합하여 제공
|
||||
*/
|
||||
@Data
|
||||
@Builder
|
||||
@NoArgsConstructor
|
||||
@AllArgsConstructor
|
||||
public class UserTimelineAnalyticsResponse {
|
||||
|
||||
/**
|
||||
* 사용자 ID
|
||||
*/
|
||||
private String userId;
|
||||
|
||||
/**
|
||||
* 조회 기간 정보
|
||||
*/
|
||||
private PeriodInfo period;
|
||||
|
||||
/**
|
||||
* 전체 이벤트 수
|
||||
*/
|
||||
private Integer totalEvents;
|
||||
|
||||
/**
|
||||
* 시간 간격 (hourly, daily, weekly, monthly)
|
||||
*/
|
||||
private String interval;
|
||||
|
||||
/**
|
||||
* 시간대별 데이터 포인트 (모든 이벤트 통합)
|
||||
*/
|
||||
private List<TimelineDataPoint> dataPoints;
|
||||
|
||||
/**
|
||||
* 트렌드 분석
|
||||
*/
|
||||
private TrendAnalysis trend;
|
||||
|
||||
/**
|
||||
* 피크 시간 정보
|
||||
*/
|
||||
private PeakTimeInfo peakTime;
|
||||
|
||||
/**
|
||||
* 마지막 업데이트 시간
|
||||
*/
|
||||
private LocalDateTime lastUpdatedAt;
|
||||
|
||||
/**
|
||||
* 데이터 출처
|
||||
*/
|
||||
private String dataSource;
|
||||
}
|
||||
@@ -125,4 +125,11 @@ public class ChannelStats extends BaseTimeEntity {
|
||||
@Column(name = "average_duration")
|
||||
@Builder.Default
|
||||
private Integer averageDuration = 0;
|
||||
|
||||
/**
|
||||
* 참여자 수 증가
|
||||
*/
|
||||
public void incrementParticipants() {
|
||||
this.participants++;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -37,10 +37,10 @@ public class EventStats extends BaseTimeEntity {
|
||||
private String eventTitle;
|
||||
|
||||
/**
|
||||
* 매장 ID (소유자)
|
||||
* 사용자 ID (소유자)
|
||||
*/
|
||||
@Column(nullable = false, length = 50)
|
||||
private String storeId;
|
||||
private String userId;
|
||||
|
||||
/**
|
||||
* 총 참여자 수
|
||||
@@ -63,6 +63,13 @@ public class EventStats extends BaseTimeEntity {
|
||||
@Builder.Default
|
||||
private BigDecimal estimatedRoi = BigDecimal.ZERO;
|
||||
|
||||
/**
|
||||
* 목표 ROI (%)
|
||||
*/
|
||||
@Column(precision = 10, scale = 2)
|
||||
@Builder.Default
|
||||
private BigDecimal targetRoi = BigDecimal.ZERO;
|
||||
|
||||
/**
|
||||
* 매출 증가율 (%)
|
||||
*/
|
||||
|
||||
+8
-3
@@ -32,7 +32,7 @@ public class DistributionCompletedConsumer {
|
||||
private final ObjectMapper objectMapper;
|
||||
private final RedisTemplate<String, String> redisTemplate;
|
||||
|
||||
private static final String PROCESSED_DISTRIBUTIONS_KEY = "distribution_completed";
|
||||
private static final String PROCESSED_DISTRIBUTIONS_KEY = "distribution_completed_v2";
|
||||
private static final String CACHE_KEY_PREFIX = "analytics:dashboard:";
|
||||
private static final long IDEMPOTENCY_TTL_DAYS = 7;
|
||||
|
||||
@@ -109,10 +109,15 @@ public class DistributionCompletedConsumer {
|
||||
channelStats.setImpressions(channel.getExpectedViews());
|
||||
}
|
||||
|
||||
// 배포 비용 저장
|
||||
if (channel.getDistributionCost() != null) {
|
||||
channelStats.setDistributionCost(channel.getDistributionCost());
|
||||
}
|
||||
|
||||
channelStatsRepository.save(channelStats);
|
||||
|
||||
log.debug("✅ 채널 통계 저장: eventId={}, channel={}, expectedViews={}",
|
||||
eventId, channelName, channel.getExpectedViews());
|
||||
log.debug("✅ 채널 통계 저장: eventId={}, channel={}, expectedViews={}, distributionCost={}",
|
||||
eventId, channelName, channel.getExpectedViews(), channel.getDistributionCost());
|
||||
|
||||
} catch (Exception e) {
|
||||
log.error("❌ 채널 통계 처리 실패: eventId={}, channel={}", eventId, channel.getChannel(), e);
|
||||
|
||||
+7
-4
@@ -12,6 +12,7 @@ import org.springframework.kafka.annotation.KafkaListener;
|
||||
import org.springframework.stereotype.Component;
|
||||
import org.springframework.transaction.annotation.Transactional;
|
||||
|
||||
import java.math.BigDecimal;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
/**
|
||||
@@ -29,7 +30,7 @@ public class EventCreatedConsumer {
|
||||
private final ObjectMapper objectMapper;
|
||||
private final RedisTemplate<String, String> redisTemplate;
|
||||
|
||||
private static final String PROCESSED_EVENTS_KEY = "processed_events";
|
||||
private static final String PROCESSED_EVENTS_KEY = "processed_events_v2";
|
||||
private static final String CACHE_KEY_PREFIX = "analytics:dashboard:";
|
||||
private static final long IDEMPOTENCY_TTL_DAYS = 7;
|
||||
|
||||
@@ -54,18 +55,20 @@ public class EventCreatedConsumer {
|
||||
return;
|
||||
}
|
||||
|
||||
// 2. 이벤트 통계 초기화
|
||||
// 2. 이벤트 통계 초기화 (1:1 관계: storeId → userId 매핑)
|
||||
EventStats eventStats = EventStats.builder()
|
||||
.eventId(eventId)
|
||||
.eventTitle(event.getEventTitle())
|
||||
.storeId(event.getStoreId())
|
||||
.userId(event.getStoreId()) // MVP: 1 user = 1 store, storeId를 userId로 매핑
|
||||
.totalParticipants(0)
|
||||
.totalInvestment(event.getTotalInvestment())
|
||||
.expectedRevenue(event.getExpectedRevenue() != null ? event.getExpectedRevenue() : BigDecimal.ZERO)
|
||||
.status(event.getStatus())
|
||||
.build();
|
||||
|
||||
eventStatsRepository.save(eventStats);
|
||||
log.info("✅ 이벤트 통계 초기화 완료: eventId={}", eventId);
|
||||
log.info("✅ 이벤트 통계 초기화 완료: eventId={}, userId={}, expectedRevenue={}",
|
||||
eventId, eventStats.getUserId(), event.getExpectedRevenue());
|
||||
|
||||
// 3. 캐시 무효화 (다음 조회 시 최신 데이터 반영)
|
||||
String cacheKey = CACHE_KEY_PREFIX + eventId;
|
||||
|
||||
+27
-8
@@ -1,7 +1,9 @@
|
||||
package com.kt.event.analytics.messaging.consumer;
|
||||
|
||||
import com.kt.event.analytics.entity.ChannelStats;
|
||||
import com.kt.event.analytics.entity.EventStats;
|
||||
import com.kt.event.analytics.messaging.event.ParticipantRegisteredEvent;
|
||||
import com.kt.event.analytics.repository.ChannelStatsRepository;
|
||||
import com.kt.event.analytics.repository.EventStatsRepository;
|
||||
import com.fasterxml.jackson.databind.ObjectMapper;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
@@ -26,10 +28,11 @@ import java.util.concurrent.TimeUnit;
|
||||
public class ParticipantRegisteredConsumer {
|
||||
|
||||
private final EventStatsRepository eventStatsRepository;
|
||||
private final ChannelStatsRepository channelStatsRepository;
|
||||
private final ObjectMapper objectMapper;
|
||||
private final RedisTemplate<String, String> redisTemplate;
|
||||
|
||||
private static final String PROCESSED_PARTICIPANTS_KEY = "processed_participants";
|
||||
private static final String PROCESSED_PARTICIPANTS_KEY = "processed_participants_v2";
|
||||
private static final String CACHE_KEY_PREFIX = "analytics:dashboard:";
|
||||
private static final long IDEMPOTENCY_TTL_DAYS = 7;
|
||||
|
||||
@@ -47,11 +50,13 @@ public class ParticipantRegisteredConsumer {
|
||||
ParticipantRegisteredEvent event = objectMapper.readValue(message, ParticipantRegisteredEvent.class);
|
||||
String participantId = event.getParticipantId();
|
||||
String eventId = event.getEventId();
|
||||
String channel = event.getChannel();
|
||||
|
||||
// ✅ 1. 멱등성 체크 (중복 처리 방지)
|
||||
Boolean isProcessed = redisTemplate.opsForSet().isMember(PROCESSED_PARTICIPANTS_KEY, participantId);
|
||||
// ✅ 1. 멱등성 체크 (중복 처리 방지) - eventId:participantId 조합으로 체크
|
||||
String idempotencyKey = eventId + ":" + participantId;
|
||||
Boolean isProcessed = redisTemplate.opsForSet().isMember(PROCESSED_PARTICIPANTS_KEY, idempotencyKey);
|
||||
if (Boolean.TRUE.equals(isProcessed)) {
|
||||
log.warn("⚠️ 중복 이벤트 스킵 (이미 처리됨): participantId={}", participantId);
|
||||
log.warn("⚠️ 중복 이벤트 스킵 (이미 처리됨): eventId={}, participantId={}", eventId, participantId);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -67,15 +72,29 @@ public class ParticipantRegisteredConsumer {
|
||||
() -> log.warn("⚠️ 이벤트 통계 없음: eventId={}", eventId)
|
||||
);
|
||||
|
||||
// 3. 캐시 무효화 (다음 조회 시 최신 참여자 수 반영)
|
||||
// 3. 채널별 참여자 수 업데이트 - 비관적 락 적용
|
||||
if (channel != null && !channel.isEmpty()) {
|
||||
channelStatsRepository.findByEventIdAndChannelNameWithLock(eventId, channel)
|
||||
.ifPresentOrElse(
|
||||
channelStats -> {
|
||||
channelStats.incrementParticipants();
|
||||
channelStatsRepository.save(channelStats);
|
||||
log.info("✅ 채널별 참여자 수 업데이트: eventId={}, channel={}, participants={}",
|
||||
eventId, channel, channelStats.getParticipants());
|
||||
},
|
||||
() -> log.warn("⚠️ 채널 통계 없음: eventId={}, channel={}", eventId, channel)
|
||||
);
|
||||
}
|
||||
|
||||
// 4. 캐시 무효화 (다음 조회 시 최신 참여자 수 반영)
|
||||
String cacheKey = CACHE_KEY_PREFIX + eventId;
|
||||
redisTemplate.delete(cacheKey);
|
||||
log.debug("🗑️ 캐시 무효화: {}", cacheKey);
|
||||
|
||||
// 4. 멱등성 처리 완료 기록 (7일 TTL)
|
||||
redisTemplate.opsForSet().add(PROCESSED_PARTICIPANTS_KEY, participantId);
|
||||
// 5. 멱등성 처리 완료 기록 (7일 TTL)
|
||||
redisTemplate.opsForSet().add(PROCESSED_PARTICIPANTS_KEY, idempotencyKey);
|
||||
redisTemplate.expire(PROCESSED_PARTICIPANTS_KEY, IDEMPOTENCY_TTL_DAYS, TimeUnit.DAYS);
|
||||
log.debug("✅ 멱등성 기록: participantId={}", participantId);
|
||||
log.debug("✅ 멱등성 기록: eventId={}, participantId={}", eventId, participantId);
|
||||
|
||||
} catch (Exception e) {
|
||||
log.error("❌ ParticipantRegistered 이벤트 처리 실패: {}", e.getMessage(), e);
|
||||
|
||||
+5
@@ -62,5 +62,10 @@ public class DistributionCompletedEvent {
|
||||
* 예상 노출 수
|
||||
*/
|
||||
private Integer expectedViews;
|
||||
|
||||
/**
|
||||
* 배포 비용 (원)
|
||||
*/
|
||||
private java.math.BigDecimal distributionCost;
|
||||
}
|
||||
}
|
||||
|
||||
+5
@@ -36,6 +36,11 @@ public class EventCreatedEvent {
|
||||
*/
|
||||
private BigDecimal totalInvestment;
|
||||
|
||||
/**
|
||||
* 예상 수익
|
||||
*/
|
||||
private BigDecimal expectedRevenue;
|
||||
|
||||
/**
|
||||
* 이벤트 상태
|
||||
*/
|
||||
|
||||
+24
@@ -1,7 +1,11 @@
|
||||
package com.kt.event.analytics.repository;
|
||||
|
||||
import com.kt.event.analytics.entity.ChannelStats;
|
||||
import jakarta.persistence.LockModeType;
|
||||
import org.springframework.data.jpa.repository.JpaRepository;
|
||||
import org.springframework.data.jpa.repository.Lock;
|
||||
import org.springframework.data.jpa.repository.Query;
|
||||
import org.springframework.data.repository.query.Param;
|
||||
import org.springframework.stereotype.Repository;
|
||||
|
||||
import java.util.List;
|
||||
@@ -29,4 +33,24 @@ public interface ChannelStatsRepository extends JpaRepository<ChannelStats, Long
|
||||
* @return 채널 통계
|
||||
*/
|
||||
Optional<ChannelStats> findByEventIdAndChannelName(String eventId, String channelName);
|
||||
|
||||
/**
|
||||
* 이벤트 ID와 채널명으로 통계 조회 (비관적 락)
|
||||
*
|
||||
* @param eventId 이벤트 ID
|
||||
* @param channelName 채널명
|
||||
* @return 채널 통계
|
||||
*/
|
||||
@Lock(LockModeType.PESSIMISTIC_WRITE)
|
||||
@Query("SELECT c FROM ChannelStats c WHERE c.eventId = :eventId AND c.channelName = :channelName")
|
||||
Optional<ChannelStats> findByEventIdAndChannelNameWithLock(@Param("eventId") String eventId,
|
||||
@Param("channelName") String channelName);
|
||||
|
||||
/**
|
||||
* 여러 이벤트 ID로 모든 채널 통계 조회
|
||||
*
|
||||
* @param eventIds 이벤트 ID 목록
|
||||
* @return 채널 통계 목록
|
||||
*/
|
||||
List<ChannelStats> findByEventIdIn(List<String> eventIds);
|
||||
}
|
||||
|
||||
+11
-3
@@ -39,11 +39,19 @@ public interface EventStatsRepository extends JpaRepository<EventStats, Long> {
|
||||
Optional<EventStats> findByEventIdWithLock(@Param("eventId") String eventId);
|
||||
|
||||
/**
|
||||
* 매장 ID와 이벤트 ID로 통계 조회
|
||||
* 사용자 ID와 이벤트 ID로 통계 조회
|
||||
*
|
||||
* @param storeId 매장 ID
|
||||
* @param userId 사용자 ID
|
||||
* @param eventId 이벤트 ID
|
||||
* @return 이벤트 통계
|
||||
*/
|
||||
Optional<EventStats> findByStoreIdAndEventId(String storeId, String eventId);
|
||||
Optional<EventStats> findByUserIdAndEventId(String userId, String eventId);
|
||||
|
||||
/**
|
||||
* 사용자 ID로 모든 이벤트 통계 조회
|
||||
*
|
||||
* @param userId 사용자 ID
|
||||
* @return 이벤트 통계 목록
|
||||
*/
|
||||
java.util.List<EventStats> findAllByUserId(String userId);
|
||||
}
|
||||
|
||||
+23
@@ -37,4 +37,27 @@ public interface TimelineDataRepository extends JpaRepository<TimelineData, Long
|
||||
@Param("startDate") LocalDateTime startDate,
|
||||
@Param("endDate") LocalDateTime endDate
|
||||
);
|
||||
|
||||
/**
|
||||
* 여러 이벤트 ID로 시간대별 데이터 조회 (시간 순 정렬)
|
||||
*
|
||||
* @param eventIds 이벤트 ID 목록
|
||||
* @return 시간대별 데이터 목록
|
||||
*/
|
||||
List<TimelineData> findByEventIdInOrderByTimestampAsc(List<String> eventIds);
|
||||
|
||||
/**
|
||||
* 여러 이벤트 ID와 기간으로 시간대별 데이터 조회
|
||||
*
|
||||
* @param eventIds 이벤트 ID 목록
|
||||
* @param startDate 시작 날짜
|
||||
* @param endDate 종료 날짜
|
||||
* @return 시간대별 데이터 목록
|
||||
*/
|
||||
@Query("SELECT t FROM TimelineData t WHERE t.eventId IN :eventIds AND t.timestamp BETWEEN :startDate AND :endDate ORDER BY t.timestamp ASC")
|
||||
List<TimelineData> findByEventIdInAndTimestampBetween(
|
||||
@Param("eventIds") List<String> eventIds,
|
||||
@Param("startDate") LocalDateTime startDate,
|
||||
@Param("endDate") LocalDateTime endDate
|
||||
);
|
||||
}
|
||||
|
||||
+111
-16
@@ -47,12 +47,10 @@ public class AnalyticsService {
|
||||
* 대시보드 데이터 조회
|
||||
*
|
||||
* @param eventId 이벤트 ID
|
||||
* @param startDate 조회 시작 날짜 (선택)
|
||||
* @param endDate 조회 종료 날짜 (선택)
|
||||
* @param refresh 캐시 갱신 여부
|
||||
* @return 대시보드 응답
|
||||
* @param refresh 캐시 갱신 여부
|
||||
* @return 대시보드 응답 (이벤트 시작일 ~ 현재까지)
|
||||
*/
|
||||
public AnalyticsDashboardResponse getDashboardData(String eventId, LocalDateTime startDate, LocalDateTime endDate, boolean refresh) {
|
||||
public AnalyticsDashboardResponse getDashboardData(String eventId, boolean refresh) {
|
||||
log.info("대시보드 데이터 조회 시작: eventId={}, refresh={}", eventId, refresh);
|
||||
|
||||
String cacheKey = CACHE_KEY_PREFIX + eventId;
|
||||
@@ -91,7 +89,7 @@ public class AnalyticsService {
|
||||
}
|
||||
|
||||
// 3. 대시보드 데이터 구성
|
||||
AnalyticsDashboardResponse response = buildDashboardData(eventStats, channelStatsList, startDate, endDate);
|
||||
AnalyticsDashboardResponse response = buildDashboardData(eventStats, channelStatsList);
|
||||
|
||||
// 4. Redis 캐싱 (1시간 TTL)
|
||||
try {
|
||||
@@ -110,10 +108,9 @@ public class AnalyticsService {
|
||||
/**
|
||||
* 대시보드 데이터 구성
|
||||
*/
|
||||
private AnalyticsDashboardResponse buildDashboardData(EventStats eventStats, List<ChannelStats> channelStatsList,
|
||||
LocalDateTime startDate, LocalDateTime endDate) {
|
||||
// 기간 정보
|
||||
PeriodInfo period = buildPeriodInfo(startDate, endDate);
|
||||
private AnalyticsDashboardResponse buildDashboardData(EventStats eventStats, List<ChannelStats> channelStatsList) {
|
||||
// 기간 정보 (이벤트 시작일 ~ 현재)
|
||||
PeriodInfo period = buildPeriodInfo(eventStats);
|
||||
|
||||
// 성과 요약
|
||||
AnalyticsSummary summary = buildAnalyticsSummary(eventStats, channelStatsList);
|
||||
@@ -124,6 +121,15 @@ public class AnalyticsService {
|
||||
// ROI 요약
|
||||
RoiSummary roiSummary = roiCalculator.calculateRoiSummary(eventStats);
|
||||
|
||||
// 투자 비용 상세
|
||||
InvestmentDetails investment = buildInvestmentDetails(eventStats, channelStatsList);
|
||||
|
||||
// 수익 상세
|
||||
RevenueDetails revenue = buildRevenueDetails(eventStats);
|
||||
|
||||
// 비용 효율성
|
||||
CostEfficiency costEfficiency = buildCostEfficiency(eventStats);
|
||||
|
||||
return AnalyticsDashboardResponse.builder()
|
||||
.eventId(eventStats.getEventId())
|
||||
.eventTitle(eventStats.getEventTitle())
|
||||
@@ -131,17 +137,20 @@ public class AnalyticsService {
|
||||
.summary(summary)
|
||||
.channelPerformance(channelPerformance)
|
||||
.roi(roiSummary)
|
||||
.investment(investment)
|
||||
.revenue(revenue)
|
||||
.costEfficiency(costEfficiency)
|
||||
.lastUpdatedAt(LocalDateTime.now())
|
||||
.dataSource("cached")
|
||||
.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* 기간 정보 구성
|
||||
* 기간 정보 구성 (이벤트 생성일 ~ 현재)
|
||||
*/
|
||||
private PeriodInfo buildPeriodInfo(LocalDateTime startDate, LocalDateTime endDate) {
|
||||
LocalDateTime start = startDate != null ? startDate : LocalDateTime.now().minusDays(30);
|
||||
LocalDateTime end = endDate != null ? endDate : LocalDateTime.now();
|
||||
private PeriodInfo buildPeriodInfo(EventStats eventStats) {
|
||||
LocalDateTime start = eventStats.getCreatedAt();
|
||||
LocalDateTime end = LocalDateTime.now();
|
||||
|
||||
long durationDays = ChronoUnit.DAYS.between(start, end);
|
||||
|
||||
@@ -179,12 +188,14 @@ public class AnalyticsService {
|
||||
.build();
|
||||
|
||||
return AnalyticsSummary.builder()
|
||||
.totalParticipants(eventStats.getTotalParticipants())
|
||||
.participants(eventStats.getTotalParticipants())
|
||||
.participantsDelta(0) // TODO: 이전 기간 데이터와 비교하여 계산
|
||||
.totalViews(totalViews)
|
||||
.totalReach(totalReach)
|
||||
.engagementRate(Math.round(engagementRate * 10.0) / 10.0)
|
||||
.conversionRate(Math.round(conversionRate * 10.0) / 10.0)
|
||||
.averageEngagementTime(145) // 고정값 (실제로는 외부 API에서 가져와야 함)
|
||||
.targetRoi(eventStats.getTargetRoi() != null ? eventStats.getTargetRoi().doubleValue() : null)
|
||||
.socialInteractions(socialStats)
|
||||
.build();
|
||||
}
|
||||
@@ -202,7 +213,7 @@ public class AnalyticsService {
|
||||
(stats.getParticipants() * 100.0 / stats.getDistributionCost().doubleValue()) : 0.0;
|
||||
|
||||
summaries.add(ChannelSummary.builder()
|
||||
.channelName(stats.getChannelName())
|
||||
.channel(stats.getChannelName())
|
||||
.views(stats.getViews())
|
||||
.participants(stats.getParticipants())
|
||||
.engagementRate(Math.round(engagementRate * 10.0) / 10.0)
|
||||
@@ -213,4 +224,88 @@ public class AnalyticsService {
|
||||
|
||||
return summaries;
|
||||
}
|
||||
|
||||
/**
|
||||
* 투자 비용 상세 구성
|
||||
*
|
||||
* UserRoiAnalyticsService와 동일한 로직:
|
||||
* - 실제 채널 배포 비용 집계
|
||||
* - 나머지 비용 분배: 경품 50%, 콘텐츠 제작 30%, 운영 20%
|
||||
*/
|
||||
private InvestmentDetails buildInvestmentDetails(EventStats eventStats, List<ChannelStats> channelStatsList) {
|
||||
java.math.BigDecimal totalInvestment = eventStats.getTotalInvestment();
|
||||
|
||||
// ChannelStats에서 실제 배포 비용 집계
|
||||
java.math.BigDecimal actualDistribution = channelStatsList.stream()
|
||||
.map(ChannelStats::getDistributionCost)
|
||||
.reduce(java.math.BigDecimal.ZERO, java.math.BigDecimal::add);
|
||||
|
||||
// 나머지 비용 계산 (총 투자 - 실제 채널 배포 비용)
|
||||
java.math.BigDecimal remaining = totalInvestment.subtract(actualDistribution);
|
||||
|
||||
// 나머지 비용 분배: 경품 50%, 콘텐츠 제작 30%, 운영 20%
|
||||
java.math.BigDecimal prizeCost = remaining.multiply(java.math.BigDecimal.valueOf(0.50));
|
||||
java.math.BigDecimal contentCreation = remaining.multiply(java.math.BigDecimal.valueOf(0.30));
|
||||
java.math.BigDecimal operation = remaining.multiply(java.math.BigDecimal.valueOf(0.20));
|
||||
|
||||
return InvestmentDetails.builder()
|
||||
.total(totalInvestment)
|
||||
.contentCreation(contentCreation)
|
||||
.operation(operation)
|
||||
.distribution(actualDistribution)
|
||||
.prizeCost(prizeCost)
|
||||
.channelCost(actualDistribution) // 채널비용은 배포비용과 동일
|
||||
.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* 수익 상세 구성
|
||||
*
|
||||
* UserRoiAnalyticsService와 동일한 로직:
|
||||
* - 직접 매출 70%, 예상 추가 매출 30%
|
||||
* - 신규 고객 40%, 기존 고객 60%
|
||||
*/
|
||||
private RevenueDetails buildRevenueDetails(EventStats eventStats) {
|
||||
java.math.BigDecimal totalRevenue = eventStats.getExpectedRevenue();
|
||||
|
||||
// 매출 분배: 직접 매출 70%, 예상 추가 매출 30%
|
||||
java.math.BigDecimal directSales = totalRevenue.multiply(java.math.BigDecimal.valueOf(0.70));
|
||||
java.math.BigDecimal expectedSales = totalRevenue.multiply(java.math.BigDecimal.valueOf(0.30));
|
||||
|
||||
// 신규 고객 40%, 기존 고객 60%
|
||||
java.math.BigDecimal newCustomerRevenue = totalRevenue.multiply(java.math.BigDecimal.valueOf(0.40));
|
||||
java.math.BigDecimal existingCustomerRevenue = totalRevenue.multiply(java.math.BigDecimal.valueOf(0.60));
|
||||
|
||||
return RevenueDetails.builder()
|
||||
.total(totalRevenue)
|
||||
.directSales(directSales)
|
||||
.expectedSales(expectedSales)
|
||||
.newCustomerRevenue(newCustomerRevenue)
|
||||
.existingCustomerRevenue(existingCustomerRevenue)
|
||||
.brandValue(java.math.BigDecimal.ZERO) // 브랜드 가치는 별도 계산 필요 시 추가
|
||||
.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* 비용 효율성 구성
|
||||
*
|
||||
* UserRoiAnalyticsService와 동일한 로직:
|
||||
* - 참여자당 비용 = 총투자 ÷ 총참여자수
|
||||
* - 참여자당 수익 = 총수익 ÷ 총참여자수
|
||||
*/
|
||||
private CostEfficiency buildCostEfficiency(EventStats eventStats) {
|
||||
int totalParticipants = eventStats.getTotalParticipants();
|
||||
java.math.BigDecimal totalInvestment = eventStats.getTotalInvestment();
|
||||
java.math.BigDecimal totalRevenue = eventStats.getExpectedRevenue();
|
||||
|
||||
double costPerParticipant = totalParticipants > 0 ?
|
||||
totalInvestment.doubleValue() / totalParticipants : 0.0;
|
||||
double revenuePerParticipant = totalParticipants > 0 ?
|
||||
totalRevenue.doubleValue() / totalParticipants : 0.0;
|
||||
|
||||
return CostEfficiency.builder()
|
||||
.costPerParticipant(costPerParticipant)
|
||||
.revenuePerParticipant(revenuePerParticipant)
|
||||
.build();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -60,43 +60,62 @@ public class ROICalculator {
|
||||
|
||||
/**
|
||||
* 투자 비용 계산
|
||||
*
|
||||
* UserRoiAnalyticsService와 동일한 로직:
|
||||
* - ChannelStats에서 실제 배포 비용 집계
|
||||
* - 나머지 비용 분배: 경품 50%, 콘텐츠 제작 30%, 운영 20%
|
||||
*/
|
||||
private InvestmentDetails calculateInvestment(EventStats eventStats, List<ChannelStats> channelStats) {
|
||||
BigDecimal distributionCost = channelStats.stream()
|
||||
BigDecimal totalInvestment = eventStats.getTotalInvestment();
|
||||
|
||||
// ChannelStats에서 실제 배포 비용 집계
|
||||
BigDecimal actualDistribution = channelStats.stream()
|
||||
.map(ChannelStats::getDistributionCost)
|
||||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||||
|
||||
BigDecimal contentCreation = eventStats.getTotalInvestment()
|
||||
.multiply(BigDecimal.valueOf(0.4)); // 전체 투자의 40%를 콘텐츠 제작비로 가정
|
||||
// 나머지 비용 계산 (총 투자 - 실제 채널 배포 비용)
|
||||
BigDecimal remaining = totalInvestment.subtract(actualDistribution);
|
||||
|
||||
BigDecimal operation = eventStats.getTotalInvestment()
|
||||
.multiply(BigDecimal.valueOf(0.1)); // 10%를 운영비로 가정
|
||||
// 나머지 비용 분배: 경품 50%, 콘텐츠 제작 30%, 운영 20%
|
||||
BigDecimal prizeCost = remaining.multiply(BigDecimal.valueOf(0.50));
|
||||
BigDecimal contentCreation = remaining.multiply(BigDecimal.valueOf(0.30));
|
||||
BigDecimal operation = remaining.multiply(BigDecimal.valueOf(0.20));
|
||||
|
||||
return InvestmentDetails.builder()
|
||||
.total(totalInvestment)
|
||||
.contentCreation(contentCreation)
|
||||
.distribution(distributionCost)
|
||||
.operation(operation)
|
||||
.total(eventStats.getTotalInvestment())
|
||||
.distribution(actualDistribution)
|
||||
.prizeCost(prizeCost)
|
||||
.channelCost(actualDistribution) // 채널비용은 배포비용과 동일
|
||||
.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* 수익 계산
|
||||
*
|
||||
* UserRoiAnalyticsService와 동일한 로직:
|
||||
* - 직접 매출 70%, 예상 추가 매출 30%
|
||||
* - 신규 고객 40%, 기존 고객 60%
|
||||
*/
|
||||
private RevenueDetails calculateRevenue(EventStats eventStats) {
|
||||
BigDecimal directSales = eventStats.getExpectedRevenue()
|
||||
.multiply(BigDecimal.valueOf(0.66)); // 예상 수익의 66%를 직접 매출로 가정
|
||||
BigDecimal totalRevenue = eventStats.getExpectedRevenue();
|
||||
|
||||
BigDecimal expectedSales = eventStats.getExpectedRevenue()
|
||||
.multiply(BigDecimal.valueOf(0.34)); // 34%를 예상 추가 매출로 가정
|
||||
// 매출 분배: 직접 매출 70%, 예상 추가 매출 30%
|
||||
BigDecimal directSales = totalRevenue.multiply(BigDecimal.valueOf(0.70));
|
||||
BigDecimal expectedSales = totalRevenue.multiply(BigDecimal.valueOf(0.30));
|
||||
|
||||
BigDecimal brandValue = BigDecimal.ZERO; // 브랜드 가치는 별도 계산 필요
|
||||
// 신규 고객 40%, 기존 고객 60%
|
||||
BigDecimal newCustomerRevenue = totalRevenue.multiply(BigDecimal.valueOf(0.40));
|
||||
BigDecimal existingCustomerRevenue = totalRevenue.multiply(BigDecimal.valueOf(0.60));
|
||||
|
||||
return RevenueDetails.builder()
|
||||
.total(totalRevenue)
|
||||
.directSales(directSales)
|
||||
.expectedSales(expectedSales)
|
||||
.brandValue(brandValue)
|
||||
.total(eventStats.getExpectedRevenue())
|
||||
.newCustomerRevenue(newCustomerRevenue)
|
||||
.existingCustomerRevenue(existingCustomerRevenue)
|
||||
.brandValue(BigDecimal.ZERO) // 브랜드 가치는 별도 계산 필요 시 추가
|
||||
.build();
|
||||
}
|
||||
|
||||
@@ -192,7 +211,7 @@ public class ROICalculator {
|
||||
}
|
||||
|
||||
return RoiSummary.builder()
|
||||
.totalInvestment(eventStats.getTotalInvestment())
|
||||
.totalCost(eventStats.getTotalInvestment())
|
||||
.expectedRevenue(eventStats.getExpectedRevenue())
|
||||
.netProfit(netProfit)
|
||||
.roi(roi)
|
||||
|
||||
+4
-11
@@ -26,20 +26,13 @@ public class TimelineAnalyticsService {
|
||||
private final TimelineDataRepository timelineDataRepository;
|
||||
|
||||
/**
|
||||
* 시간대별 참여 추이 조회
|
||||
* 시간대별 참여 추이 조회 (이벤트 전체 기간)
|
||||
*/
|
||||
public TimelineAnalyticsResponse getTimelineAnalytics(String eventId, String interval,
|
||||
LocalDateTime startDate, LocalDateTime endDate,
|
||||
List<String> metrics) {
|
||||
public TimelineAnalyticsResponse getTimelineAnalytics(String eventId, String interval, List<String> metrics) {
|
||||
log.info("시간대별 참여 추이 조회: eventId={}, interval={}", eventId, interval);
|
||||
|
||||
// 시간대별 데이터 조회
|
||||
List<TimelineData> timelineDataList;
|
||||
if (startDate != null && endDate != null) {
|
||||
timelineDataList = timelineDataRepository.findByEventIdAndTimestampBetween(eventId, startDate, endDate);
|
||||
} else {
|
||||
timelineDataList = timelineDataRepository.findByEventIdOrderByTimestampAsc(eventId);
|
||||
}
|
||||
// 시간대별 데이터 조회 (이벤트 전체 기간)
|
||||
List<TimelineData> timelineDataList = timelineDataRepository.findByEventIdOrderByTimestampAsc(eventId);
|
||||
|
||||
// 시간대별 데이터 포인트 구성
|
||||
List<TimelineDataPoint> dataPoints = buildTimelineDataPoints(timelineDataList);
|
||||
|
||||
+350
@@ -0,0 +1,350 @@
|
||||
package com.kt.event.analytics.service;
|
||||
|
||||
import com.kt.event.analytics.dto.response.*;
|
||||
import com.kt.event.analytics.entity.ChannelStats;
|
||||
import com.kt.event.analytics.entity.EventStats;
|
||||
import com.kt.event.analytics.repository.ChannelStatsRepository;
|
||||
import com.kt.event.analytics.repository.EventStatsRepository;
|
||||
import com.fasterxml.jackson.core.JsonProcessingException;
|
||||
import com.fasterxml.jackson.databind.ObjectMapper;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.data.redis.core.RedisTemplate;
|
||||
import org.springframework.stereotype.Service;
|
||||
import org.springframework.transaction.annotation.Transactional;
|
||||
|
||||
import java.math.BigDecimal;
|
||||
import java.math.RoundingMode;
|
||||
import java.time.LocalDateTime;
|
||||
import java.time.temporal.ChronoUnit;
|
||||
import java.util.*;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
/**
|
||||
* User Analytics Service
|
||||
*
|
||||
* 매장(사용자) 전체 이벤트의 통합 성과 대시보드를 제공하는 서비스
|
||||
*/
|
||||
@Slf4j
|
||||
@Service
|
||||
@RequiredArgsConstructor
|
||||
@Transactional(readOnly = true)
|
||||
public class UserAnalyticsService {
|
||||
|
||||
private final EventStatsRepository eventStatsRepository;
|
||||
private final ChannelStatsRepository channelStatsRepository;
|
||||
private final ROICalculator roiCalculator;
|
||||
private final RedisTemplate<String, String> redisTemplate;
|
||||
private final ObjectMapper objectMapper;
|
||||
|
||||
private static final String CACHE_KEY_PREFIX = "analytics:user:dashboard:";
|
||||
private static final long CACHE_TTL = 1800; // 30분 (여러 이벤트 통합이므로 짧게)
|
||||
|
||||
/**
|
||||
* 사용자 전체 대시보드 데이터 조회
|
||||
*
|
||||
* @param userId 사용자 ID
|
||||
* @param refresh 캐시 갱신 여부
|
||||
* @return 사용자 통합 대시보드 응답 (userId 기반 전체 이벤트 조회)
|
||||
*/
|
||||
public UserAnalyticsDashboardResponse getUserDashboardData(String userId, boolean refresh) {
|
||||
log.info("사용자 전체 대시보드 데이터 조회 시작: userId={}, refresh={}", userId, refresh);
|
||||
|
||||
String cacheKey = CACHE_KEY_PREFIX + userId;
|
||||
|
||||
// 1. Redis 캐시 조회 (refresh가 false일 때만)
|
||||
if (!refresh) {
|
||||
String cachedData = redisTemplate.opsForValue().get(cacheKey);
|
||||
if (cachedData != null) {
|
||||
try {
|
||||
log.info("✅ 캐시 HIT: {}", cacheKey);
|
||||
return objectMapper.readValue(cachedData, UserAnalyticsDashboardResponse.class);
|
||||
} catch (JsonProcessingException e) {
|
||||
log.warn("캐시 데이터 역직렬화 실패: {}", e.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 2. 캐시 MISS: 데이터 조회 및 통합
|
||||
log.info("캐시 MISS 또는 refresh=true: PostgreSQL 조회");
|
||||
|
||||
// 2-1. 사용자의 모든 이벤트 조회
|
||||
List<EventStats> allEvents = eventStatsRepository.findAllByUserId(userId);
|
||||
if (allEvents.isEmpty()) {
|
||||
log.warn("사용자에 이벤트가 없음: userId={}", userId);
|
||||
return buildEmptyResponse(userId);
|
||||
}
|
||||
|
||||
log.debug("사용자 이벤트 조회 완료: userId={}, 이벤트 수={}", userId, allEvents.size());
|
||||
|
||||
// 2-2. 모든 이벤트의 채널 통계 조회
|
||||
List<String> eventIds = allEvents.stream()
|
||||
.map(EventStats::getEventId)
|
||||
.collect(Collectors.toList());
|
||||
List<ChannelStats> allChannelStats = channelStatsRepository.findByEventIdIn(eventIds);
|
||||
|
||||
// 3. 통합 대시보드 데이터 구성
|
||||
UserAnalyticsDashboardResponse response = buildUserDashboardData(userId, allEvents, allChannelStats);
|
||||
|
||||
// 4. Redis 캐싱 (30분 TTL)
|
||||
try {
|
||||
String jsonData = objectMapper.writeValueAsString(response);
|
||||
redisTemplate.opsForValue().set(cacheKey, jsonData, CACHE_TTL, TimeUnit.SECONDS);
|
||||
log.info("✅ Redis 캐시 저장 완료: {} (TTL: 30분)", cacheKey);
|
||||
} catch (Exception e) {
|
||||
log.warn("캐시 저장 실패 (무시하고 계속 진행): {}", e.getMessage());
|
||||
}
|
||||
|
||||
return response;
|
||||
}
|
||||
|
||||
/**
|
||||
* 빈 응답 생성 (이벤트가 없는 경우)
|
||||
*/
|
||||
private UserAnalyticsDashboardResponse buildEmptyResponse(String userId) {
|
||||
LocalDateTime now = LocalDateTime.now();
|
||||
return UserAnalyticsDashboardResponse.builder()
|
||||
.userId(userId)
|
||||
.period(PeriodInfo.builder()
|
||||
.startDate(now)
|
||||
.endDate(now)
|
||||
.durationDays(0)
|
||||
.build())
|
||||
.totalEvents(0)
|
||||
.activeEvents(0)
|
||||
.overallSummary(buildEmptyAnalyticsSummary())
|
||||
.channelPerformance(new ArrayList<>())
|
||||
.overallRoi(buildEmptyRoiSummary())
|
||||
.eventPerformances(new ArrayList<>())
|
||||
.lastUpdatedAt(LocalDateTime.now())
|
||||
.dataSource("empty")
|
||||
.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* 사용자 통합 대시보드 데이터 구성
|
||||
*/
|
||||
private UserAnalyticsDashboardResponse buildUserDashboardData(String userId, List<EventStats> allEvents,
|
||||
List<ChannelStats> allChannelStats) {
|
||||
// 기간 정보 (전체 이벤트의 최소/최대 날짜 기반)
|
||||
PeriodInfo period = buildPeriodFromEvents(allEvents);
|
||||
|
||||
// 전체 이벤트 수 및 활성 이벤트 수
|
||||
int totalEvents = allEvents.size();
|
||||
long activeEvents = allEvents.stream()
|
||||
.filter(e -> "ACTIVE".equalsIgnoreCase(e.getStatus()) || "RUNNING".equalsIgnoreCase(e.getStatus()))
|
||||
.count();
|
||||
|
||||
// 전체 성과 요약 (모든 이벤트 통합)
|
||||
AnalyticsSummary overallSummary = buildOverallSummary(allEvents, allChannelStats);
|
||||
|
||||
// 채널별 성과 요약 (모든 이벤트 통합)
|
||||
List<ChannelSummary> channelPerformance = buildAggregatedChannelPerformance(allChannelStats, allEvents);
|
||||
|
||||
// 전체 ROI 요약
|
||||
RoiSummary overallRoi = calculateOverallRoi(allEvents);
|
||||
|
||||
// 이벤트별 성과 목록
|
||||
List<UserAnalyticsDashboardResponse.EventPerformanceSummary> eventPerformances = buildEventPerformances(allEvents);
|
||||
|
||||
return UserAnalyticsDashboardResponse.builder()
|
||||
.userId(userId)
|
||||
.period(period)
|
||||
.totalEvents(totalEvents)
|
||||
.activeEvents((int) activeEvents)
|
||||
.overallSummary(overallSummary)
|
||||
.channelPerformance(channelPerformance)
|
||||
.overallRoi(overallRoi)
|
||||
.eventPerformances(eventPerformances)
|
||||
.lastUpdatedAt(LocalDateTime.now())
|
||||
.dataSource("cached")
|
||||
.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* 전체 성과 요약 계산 (모든 이벤트 통합)
|
||||
*/
|
||||
private AnalyticsSummary buildOverallSummary(List<EventStats> allEvents, List<ChannelStats> allChannelStats) {
|
||||
int totalParticipants = allEvents.stream()
|
||||
.mapToInt(EventStats::getTotalParticipants)
|
||||
.sum();
|
||||
|
||||
int totalViews = allEvents.stream()
|
||||
.mapToInt(EventStats::getTotalViews)
|
||||
.sum();
|
||||
|
||||
BigDecimal totalInvestment = allEvents.stream()
|
||||
.map(EventStats::getTotalInvestment)
|
||||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||||
|
||||
BigDecimal totalExpectedRevenue = allEvents.stream()
|
||||
.map(EventStats::getExpectedRevenue)
|
||||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||||
|
||||
// 평균 참여율 계산
|
||||
double avgEngagementRate = totalViews > 0 ? (double) totalParticipants / totalViews * 100 : 0.0;
|
||||
|
||||
// 평균 전환율 계산 (채널 통계 기반)
|
||||
int totalConversions = allChannelStats.stream()
|
||||
.mapToInt(ChannelStats::getConversions)
|
||||
.sum();
|
||||
double avgConversionRate = totalParticipants > 0 ? (double) totalConversions / totalParticipants * 100 : 0.0;
|
||||
|
||||
return AnalyticsSummary.builder()
|
||||
.participants(totalParticipants)
|
||||
.participantsDelta(0) // TODO: 이전 기간 데이터와 비교하여 계산
|
||||
.totalViews(totalViews)
|
||||
.engagementRate(Math.round(avgEngagementRate * 10) / 10.0)
|
||||
.conversionRate(Math.round(avgConversionRate * 10) / 10.0)
|
||||
.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* 채널별 성과 통합 (모든 이벤트의 채널 데이터 집계)
|
||||
*/
|
||||
private List<ChannelSummary> buildAggregatedChannelPerformance(List<ChannelStats> allChannelStats, List<EventStats> allEvents) {
|
||||
if (allChannelStats.isEmpty()) {
|
||||
return new ArrayList<>();
|
||||
}
|
||||
|
||||
BigDecimal totalInvestment = allEvents.stream()
|
||||
.map(EventStats::getTotalInvestment)
|
||||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||||
|
||||
// 채널명별로 그룹화하여 집계
|
||||
Map<String, List<ChannelStats>> channelGroups = allChannelStats.stream()
|
||||
.collect(Collectors.groupingBy(ChannelStats::getChannelName));
|
||||
|
||||
return channelGroups.entrySet().stream()
|
||||
.map(entry -> {
|
||||
String channelName = entry.getKey();
|
||||
List<ChannelStats> channelList = entry.getValue();
|
||||
|
||||
int participants = channelList.stream().mapToInt(ChannelStats::getParticipants).sum();
|
||||
int views = channelList.stream().mapToInt(ChannelStats::getViews).sum();
|
||||
double engagementRate = views > 0 ? (double) participants / views * 100 : 0.0;
|
||||
|
||||
BigDecimal channelCost = channelList.stream()
|
||||
.map(ChannelStats::getDistributionCost)
|
||||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||||
|
||||
double channelRoi = channelCost.compareTo(BigDecimal.ZERO) > 0
|
||||
? (participants - channelCost.doubleValue()) / channelCost.doubleValue() * 100
|
||||
: 0.0;
|
||||
|
||||
return ChannelSummary.builder()
|
||||
.channel(channelName)
|
||||
.participants(participants)
|
||||
.views(views)
|
||||
.engagementRate(Math.round(engagementRate * 10) / 10.0)
|
||||
.roi(Math.round(channelRoi * 10) / 10.0)
|
||||
.build();
|
||||
})
|
||||
.sorted(Comparator.comparingInt(ChannelSummary::getParticipants).reversed())
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
|
||||
/**
|
||||
* 전체 ROI 계산
|
||||
*/
|
||||
private RoiSummary calculateOverallRoi(List<EventStats> allEvents) {
|
||||
BigDecimal totalInvestment = allEvents.stream()
|
||||
.map(EventStats::getTotalInvestment)
|
||||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||||
|
||||
BigDecimal totalExpectedRevenue = allEvents.stream()
|
||||
.map(EventStats::getExpectedRevenue)
|
||||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||||
|
||||
BigDecimal totalProfit = totalExpectedRevenue.subtract(totalInvestment);
|
||||
|
||||
Double roi = totalInvestment.compareTo(BigDecimal.ZERO) > 0
|
||||
? totalProfit.divide(totalInvestment, 4, RoundingMode.HALF_UP)
|
||||
.multiply(BigDecimal.valueOf(100))
|
||||
.doubleValue()
|
||||
: 0.0;
|
||||
|
||||
return RoiSummary.builder()
|
||||
.totalCost(totalInvestment)
|
||||
.expectedRevenue(totalExpectedRevenue)
|
||||
.netProfit(totalProfit)
|
||||
.roi(Math.round(roi * 10) / 10.0)
|
||||
.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* 이벤트별 성과 목록 생성
|
||||
*/
|
||||
private List<UserAnalyticsDashboardResponse.EventPerformanceSummary> buildEventPerformances(List<EventStats> allEvents) {
|
||||
return allEvents.stream()
|
||||
.map(event -> {
|
||||
Double roi = event.getTotalInvestment().compareTo(BigDecimal.ZERO) > 0
|
||||
? event.getExpectedRevenue().subtract(event.getTotalInvestment())
|
||||
.divide(event.getTotalInvestment(), 4, RoundingMode.HALF_UP)
|
||||
.multiply(BigDecimal.valueOf(100))
|
||||
.doubleValue()
|
||||
: 0.0;
|
||||
|
||||
return UserAnalyticsDashboardResponse.EventPerformanceSummary.builder()
|
||||
.eventId(event.getEventId())
|
||||
.eventTitle(event.getEventTitle())
|
||||
.participants(event.getTotalParticipants())
|
||||
.views(event.getTotalViews())
|
||||
.roi(Math.round(roi * 10) / 10.0)
|
||||
.status(event.getStatus())
|
||||
.build();
|
||||
})
|
||||
.sorted(Comparator.comparingInt(UserAnalyticsDashboardResponse.EventPerformanceSummary::getParticipants).reversed())
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
|
||||
/**
|
||||
* 기간 정보 구성
|
||||
*/
|
||||
/**
|
||||
* 전체 이벤트의 생성/수정 시간 기반으로 period 계산
|
||||
*/
|
||||
private PeriodInfo buildPeriodFromEvents(List<EventStats> events) {
|
||||
LocalDateTime start = events.stream()
|
||||
.map(EventStats::getCreatedAt)
|
||||
.min(LocalDateTime::compareTo)
|
||||
.orElse(LocalDateTime.now());
|
||||
|
||||
LocalDateTime end = events.stream()
|
||||
.map(EventStats::getUpdatedAt)
|
||||
.max(LocalDateTime::compareTo)
|
||||
.orElse(LocalDateTime.now());
|
||||
|
||||
return PeriodInfo.builder()
|
||||
.startDate(start)
|
||||
.endDate(end)
|
||||
.durationDays((int) ChronoUnit.DAYS.between(start, end))
|
||||
.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* 빈 성과 요약
|
||||
*/
|
||||
private AnalyticsSummary buildEmptyAnalyticsSummary() {
|
||||
return AnalyticsSummary.builder()
|
||||
.participants(0)
|
||||
.participantsDelta(0)
|
||||
.totalViews(0)
|
||||
.engagementRate(0.0)
|
||||
.conversionRate(0.0)
|
||||
.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* 빈 ROI 요약
|
||||
*/
|
||||
private RoiSummary buildEmptyRoiSummary() {
|
||||
return RoiSummary.builder()
|
||||
.totalCost(BigDecimal.ZERO)
|
||||
.expectedRevenue(BigDecimal.ZERO)
|
||||
.netProfit(BigDecimal.ZERO)
|
||||
.roi(0.0)
|
||||
.build();
|
||||
}
|
||||
}
|
||||
+268
@@ -0,0 +1,268 @@
|
||||
package com.kt.event.analytics.service;
|
||||
|
||||
import com.kt.event.analytics.dto.response.*;
|
||||
import com.kt.event.analytics.entity.ChannelStats;
|
||||
import com.kt.event.analytics.entity.EventStats;
|
||||
import com.kt.event.analytics.repository.ChannelStatsRepository;
|
||||
import com.kt.event.analytics.repository.EventStatsRepository;
|
||||
import com.fasterxml.jackson.core.JsonProcessingException;
|
||||
import com.fasterxml.jackson.databind.ObjectMapper;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.data.redis.core.RedisTemplate;
|
||||
import org.springframework.stereotype.Service;
|
||||
import org.springframework.transaction.annotation.Transactional;
|
||||
|
||||
import java.math.BigDecimal;
|
||||
import java.math.RoundingMode;
|
||||
import java.time.LocalDateTime;
|
||||
import java.time.temporal.ChronoUnit;
|
||||
import java.util.*;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.HashMap;
|
||||
|
||||
/**
|
||||
* User Channel Analytics Service
|
||||
*
|
||||
* 매장(사용자) 전체 이벤트의 채널별 성과를 통합하여 제공하는 서비스
|
||||
*/
|
||||
@Slf4j
|
||||
@Service
|
||||
@RequiredArgsConstructor
|
||||
@Transactional(readOnly = true)
|
||||
public class UserChannelAnalyticsService {
|
||||
|
||||
private final EventStatsRepository eventStatsRepository;
|
||||
private final ChannelStatsRepository channelStatsRepository;
|
||||
private final RedisTemplate<String, String> redisTemplate;
|
||||
private final ObjectMapper objectMapper;
|
||||
|
||||
private static final String CACHE_KEY_PREFIX = "analytics:user:channels:";
|
||||
private static final long CACHE_TTL = 1800; // 30분
|
||||
|
||||
/**
|
||||
* 사용자 전체 채널 분석 데이터 조회 (전체 채널 무조건 표시)
|
||||
*/
|
||||
public UserChannelAnalyticsResponse getUserChannelAnalytics(String userId, String sortBy, String order, boolean refresh) {
|
||||
log.info("사용자 채널 분석 조회 시작: userId={}, refresh={}", userId, refresh);
|
||||
|
||||
String cacheKey = CACHE_KEY_PREFIX + userId;
|
||||
|
||||
// 1. 캐시 조회
|
||||
if (!refresh) {
|
||||
String cachedData = redisTemplate.opsForValue().get(cacheKey);
|
||||
if (cachedData != null) {
|
||||
try {
|
||||
log.info("✅ 캐시 HIT: {}", cacheKey);
|
||||
return objectMapper.readValue(cachedData, UserChannelAnalyticsResponse.class);
|
||||
} catch (JsonProcessingException e) {
|
||||
log.warn("캐시 역직렬화 실패: {}", e.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 2. 데이터 조회
|
||||
List<EventStats> allEvents = eventStatsRepository.findAllByUserId(userId);
|
||||
if (allEvents.isEmpty()) {
|
||||
return buildEmptyResponse(userId);
|
||||
}
|
||||
|
||||
List<String> eventIds = allEvents.stream().map(EventStats::getEventId).collect(Collectors.toList());
|
||||
List<ChannelStats> allChannelStats = channelStatsRepository.findByEventIdIn(eventIds);
|
||||
|
||||
// 3. 응답 구성 (전체 채널)
|
||||
UserChannelAnalyticsResponse response = buildChannelAnalyticsResponse(userId, allEvents, allChannelStats, sortBy, order);
|
||||
|
||||
// 4. 캐싱
|
||||
try {
|
||||
String jsonData = objectMapper.writeValueAsString(response);
|
||||
redisTemplate.opsForValue().set(cacheKey, jsonData, CACHE_TTL, TimeUnit.SECONDS);
|
||||
log.info("✅ 캐시 저장 완료: {}", cacheKey);
|
||||
} catch (Exception e) {
|
||||
log.warn("캐시 저장 실패: {}", e.getMessage());
|
||||
}
|
||||
|
||||
return response;
|
||||
}
|
||||
|
||||
private UserChannelAnalyticsResponse buildEmptyResponse(String userId) {
|
||||
LocalDateTime now = LocalDateTime.now();
|
||||
return UserChannelAnalyticsResponse.builder()
|
||||
.userId(userId)
|
||||
.period(PeriodInfo.builder()
|
||||
.startDate(now)
|
||||
.endDate(now)
|
||||
.durationDays(0)
|
||||
.build())
|
||||
.totalEvents(0)
|
||||
.channels(new ArrayList<>())
|
||||
.comparison(ChannelComparison.builder().build())
|
||||
.lastUpdatedAt(LocalDateTime.now())
|
||||
.dataSource("empty")
|
||||
.build();
|
||||
}
|
||||
|
||||
private UserChannelAnalyticsResponse buildChannelAnalyticsResponse(String userId, List<EventStats> allEvents,
|
||||
List<ChannelStats> allChannelStats,
|
||||
String sortBy, String order) {
|
||||
// 채널별 집계 (전체 채널)
|
||||
List<ChannelAnalytics> channelAnalyticsList = aggregateChannelAnalytics(allChannelStats);
|
||||
|
||||
// 정렬
|
||||
channelAnalyticsList = sortChannels(channelAnalyticsList, sortBy, order);
|
||||
|
||||
// 채널 비교
|
||||
ChannelComparison comparison = buildChannelComparison(channelAnalyticsList);
|
||||
|
||||
return UserChannelAnalyticsResponse.builder()
|
||||
.userId(userId)
|
||||
.period(buildPeriodFromEvents(allEvents))
|
||||
.totalEvents(allEvents.size())
|
||||
.channels(channelAnalyticsList)
|
||||
.comparison(comparison)
|
||||
.lastUpdatedAt(LocalDateTime.now())
|
||||
.dataSource("cached")
|
||||
.build();
|
||||
}
|
||||
|
||||
private List<ChannelAnalytics> aggregateChannelAnalytics(List<ChannelStats> allChannelStats) {
|
||||
Map<String, List<ChannelStats>> channelGroups = allChannelStats.stream()
|
||||
.collect(Collectors.groupingBy(ChannelStats::getChannelName));
|
||||
|
||||
return channelGroups.entrySet().stream()
|
||||
.map(entry -> {
|
||||
String channelName = entry.getKey();
|
||||
List<ChannelStats> channelList = entry.getValue();
|
||||
|
||||
int views = channelList.stream().mapToInt(ChannelStats::getViews).sum();
|
||||
int participants = channelList.stream().mapToInt(ChannelStats::getParticipants).sum();
|
||||
int clicks = channelList.stream().mapToInt(ChannelStats::getClicks).sum();
|
||||
int conversions = channelList.stream().mapToInt(ChannelStats::getConversions).sum();
|
||||
|
||||
double engagementRate = views > 0 ? (double) participants / views * 100 : 0.0;
|
||||
double conversionRate = participants > 0 ? (double) conversions / participants * 100 : 0.0;
|
||||
|
||||
BigDecimal cost = channelList.stream()
|
||||
.map(ChannelStats::getDistributionCost)
|
||||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||||
|
||||
double roi = cost.compareTo(BigDecimal.ZERO) > 0
|
||||
? (participants - cost.doubleValue()) / cost.doubleValue() * 100
|
||||
: 0.0;
|
||||
|
||||
ChannelMetrics metrics = ChannelMetrics.builder()
|
||||
.impressions(channelList.stream().mapToInt(ChannelStats::getImpressions).sum())
|
||||
.views(views)
|
||||
.clicks(clicks)
|
||||
.participants(participants)
|
||||
.conversions(conversions)
|
||||
.build();
|
||||
|
||||
ChannelPerformance performance = ChannelPerformance.builder()
|
||||
.engagementRate(Math.round(engagementRate * 10) / 10.0)
|
||||
.conversionRate(Math.round(conversionRate * 10) / 10.0)
|
||||
.clickThroughRate(views > 0 ? Math.round((double) clicks / views * 1000) / 10.0 : 0.0)
|
||||
.build();
|
||||
|
||||
ChannelCosts costs = ChannelCosts.builder()
|
||||
.distributionCost(cost)
|
||||
.costPerView(views > 0 ? cost.doubleValue() / views : 0.0)
|
||||
.costPerClick(clicks > 0 ? cost.doubleValue() / clicks : 0.0)
|
||||
.costPerAcquisition(participants > 0 ? cost.doubleValue() / participants : 0.0)
|
||||
.roi(Math.round(roi * 10) / 10.0)
|
||||
.build();
|
||||
|
||||
return ChannelAnalytics.builder()
|
||||
.channelName(channelName)
|
||||
.channelType(channelList.get(0).getChannelType())
|
||||
.metrics(metrics)
|
||||
.performance(performance)
|
||||
.costs(costs)
|
||||
.build();
|
||||
})
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
|
||||
private List<ChannelAnalytics> sortChannels(List<ChannelAnalytics> channels, String sortBy, String order) {
|
||||
Comparator<ChannelAnalytics> comparator;
|
||||
|
||||
switch (sortBy != null ? sortBy.toLowerCase() : "participants") {
|
||||
case "views":
|
||||
comparator = Comparator.comparingInt(c -> c.getMetrics().getViews());
|
||||
break;
|
||||
case "engagement_rate":
|
||||
comparator = Comparator.comparingDouble(c -> c.getPerformance().getEngagementRate());
|
||||
break;
|
||||
case "conversion_rate":
|
||||
comparator = Comparator.comparingDouble(c -> c.getPerformance().getConversionRate());
|
||||
break;
|
||||
case "roi":
|
||||
comparator = Comparator.comparingDouble(c -> c.getCosts().getRoi());
|
||||
break;
|
||||
case "participants":
|
||||
default:
|
||||
comparator = Comparator.comparingInt(c -> c.getMetrics().getParticipants());
|
||||
break;
|
||||
}
|
||||
|
||||
if ("desc".equalsIgnoreCase(order)) {
|
||||
comparator = comparator.reversed();
|
||||
}
|
||||
|
||||
return channels.stream().sorted(comparator).collect(Collectors.toList());
|
||||
}
|
||||
|
||||
private ChannelComparison buildChannelComparison(List<ChannelAnalytics> channels) {
|
||||
if (channels.isEmpty()) {
|
||||
return ChannelComparison.builder().build();
|
||||
}
|
||||
|
||||
String bestPerformingChannel = channels.stream()
|
||||
.max(Comparator.comparingInt(c -> c.getMetrics().getParticipants()))
|
||||
.map(ChannelAnalytics::getChannelName)
|
||||
.orElse("N/A");
|
||||
|
||||
Map<String, String> bestPerforming = new HashMap<>();
|
||||
bestPerforming.put("channel", bestPerformingChannel);
|
||||
bestPerforming.put("metric", "participants");
|
||||
|
||||
Map<String, Double> averageMetrics = new HashMap<>();
|
||||
int totalChannels = channels.size();
|
||||
if (totalChannels > 0) {
|
||||
double avgParticipants = channels.stream().mapToInt(c -> c.getMetrics().getParticipants()).average().orElse(0.0);
|
||||
double avgEngagement = channels.stream().mapToDouble(c -> c.getPerformance().getEngagementRate()).average().orElse(0.0);
|
||||
double avgRoi = channels.stream().mapToDouble(c -> c.getCosts().getRoi()).average().orElse(0.0);
|
||||
|
||||
averageMetrics.put("participants", avgParticipants);
|
||||
averageMetrics.put("engagementRate", avgEngagement);
|
||||
averageMetrics.put("roi", avgRoi);
|
||||
}
|
||||
|
||||
return ChannelComparison.builder()
|
||||
.bestPerforming(bestPerforming)
|
||||
.averageMetrics(averageMetrics)
|
||||
.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* 전체 이벤트의 생성/수정 시간 기반으로 period 계산
|
||||
*/
|
||||
private PeriodInfo buildPeriodFromEvents(List<EventStats> events) {
|
||||
LocalDateTime start = events.stream()
|
||||
.map(EventStats::getCreatedAt)
|
||||
.min(LocalDateTime::compareTo)
|
||||
.orElse(LocalDateTime.now());
|
||||
|
||||
LocalDateTime end = events.stream()
|
||||
.map(EventStats::getUpdatedAt)
|
||||
.max(LocalDateTime::compareTo)
|
||||
.orElse(LocalDateTime.now());
|
||||
|
||||
return PeriodInfo.builder()
|
||||
.startDate(start)
|
||||
.endDate(end)
|
||||
.durationDays((int) ChronoUnit.DAYS.between(start, end))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
+237
@@ -0,0 +1,237 @@
|
||||
package com.kt.event.analytics.service;
|
||||
|
||||
import com.kt.event.analytics.dto.response.*;
|
||||
import com.kt.event.analytics.entity.ChannelStats;
|
||||
import com.kt.event.analytics.entity.EventStats;
|
||||
import com.kt.event.analytics.repository.ChannelStatsRepository;
|
||||
import com.kt.event.analytics.repository.EventStatsRepository;
|
||||
import com.fasterxml.jackson.core.JsonProcessingException;
|
||||
import com.fasterxml.jackson.databind.ObjectMapper;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.data.redis.core.RedisTemplate;
|
||||
import org.springframework.stereotype.Service;
|
||||
import org.springframework.transaction.annotation.Transactional;
|
||||
|
||||
import java.math.BigDecimal;
|
||||
import java.math.RoundingMode;
|
||||
import java.time.LocalDateTime;
|
||||
import java.time.temporal.ChronoUnit;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Comparator;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
/**
|
||||
* User ROI Analytics Service
|
||||
*/
|
||||
@Slf4j
|
||||
@Service
|
||||
@RequiredArgsConstructor
|
||||
@Transactional(readOnly = true)
|
||||
public class UserRoiAnalyticsService {
|
||||
|
||||
private final EventStatsRepository eventStatsRepository;
|
||||
private final ChannelStatsRepository channelStatsRepository;
|
||||
private final RedisTemplate<String, String> redisTemplate;
|
||||
private final ObjectMapper objectMapper;
|
||||
|
||||
private static final String CACHE_KEY_PREFIX = "analytics:user:roi:";
|
||||
private static final long CACHE_TTL = 1800;
|
||||
|
||||
public UserRoiAnalyticsResponse getUserRoiAnalytics(String userId, boolean includeProjection, boolean refresh) {
|
||||
log.info("사용자 ROI 분석 조회 시작: userId={}, refresh={}", userId, refresh);
|
||||
|
||||
String cacheKey = CACHE_KEY_PREFIX + userId;
|
||||
|
||||
if (!refresh) {
|
||||
String cachedData = redisTemplate.opsForValue().get(cacheKey);
|
||||
if (cachedData != null) {
|
||||
try {
|
||||
return objectMapper.readValue(cachedData, UserRoiAnalyticsResponse.class);
|
||||
} catch (JsonProcessingException e) {
|
||||
log.warn("캐시 역직렬화 실패: {}", e.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
List<EventStats> allEvents = eventStatsRepository.findAllByUserId(userId);
|
||||
if (allEvents.isEmpty()) {
|
||||
return buildEmptyResponse(userId);
|
||||
}
|
||||
|
||||
UserRoiAnalyticsResponse response = buildRoiResponse(userId, allEvents, includeProjection);
|
||||
|
||||
try {
|
||||
String jsonData = objectMapper.writeValueAsString(response);
|
||||
redisTemplate.opsForValue().set(cacheKey, jsonData, CACHE_TTL, TimeUnit.SECONDS);
|
||||
} catch (Exception e) {
|
||||
log.warn("캐시 저장 실패: {}", e.getMessage());
|
||||
}
|
||||
|
||||
return response;
|
||||
}
|
||||
|
||||
private UserRoiAnalyticsResponse buildEmptyResponse(String userId) {
|
||||
LocalDateTime now = LocalDateTime.now();
|
||||
return UserRoiAnalyticsResponse.builder()
|
||||
.userId(userId)
|
||||
.period(PeriodInfo.builder()
|
||||
.startDate(now)
|
||||
.endDate(now)
|
||||
.durationDays(0)
|
||||
.build())
|
||||
.totalEvents(0)
|
||||
.overallInvestment(InvestmentDetails.builder()
|
||||
.total(BigDecimal.ZERO)
|
||||
.contentCreation(BigDecimal.ZERO)
|
||||
.operation(BigDecimal.ZERO)
|
||||
.distribution(BigDecimal.ZERO)
|
||||
.prizeCost(BigDecimal.ZERO)
|
||||
.channelCost(BigDecimal.ZERO)
|
||||
.build())
|
||||
.overallRevenue(RevenueDetails.builder()
|
||||
.total(BigDecimal.ZERO)
|
||||
.directSales(BigDecimal.ZERO)
|
||||
.expectedSales(BigDecimal.ZERO)
|
||||
.newCustomerRevenue(BigDecimal.ZERO)
|
||||
.existingCustomerRevenue(BigDecimal.ZERO)
|
||||
.brandValue(BigDecimal.ZERO)
|
||||
.build())
|
||||
.overallRoi(RoiCalculation.builder()
|
||||
.netProfit(BigDecimal.ZERO)
|
||||
.roiPercentage(0.0)
|
||||
.build())
|
||||
.eventRois(new ArrayList<>())
|
||||
.lastUpdatedAt(LocalDateTime.now())
|
||||
.dataSource("empty")
|
||||
.build();
|
||||
}
|
||||
|
||||
private UserRoiAnalyticsResponse buildRoiResponse(String userId, List<EventStats> allEvents, boolean includeProjection) {
|
||||
BigDecimal totalInvestment = allEvents.stream().map(EventStats::getTotalInvestment).reduce(BigDecimal.ZERO, BigDecimal::add);
|
||||
BigDecimal totalRevenue = allEvents.stream().map(EventStats::getExpectedRevenue).reduce(BigDecimal.ZERO, BigDecimal::add);
|
||||
BigDecimal totalProfit = totalRevenue.subtract(totalInvestment);
|
||||
|
||||
Double roiPercentage = totalInvestment.compareTo(BigDecimal.ZERO) > 0
|
||||
? totalProfit.divide(totalInvestment, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100)).doubleValue()
|
||||
: 0.0;
|
||||
|
||||
// ChannelStats에서 실제 배포 비용 집계
|
||||
List<String> eventIds = allEvents.stream().map(EventStats::getEventId).collect(Collectors.toList());
|
||||
List<ChannelStats> allChannelStats = channelStatsRepository.findByEventIdIn(eventIds);
|
||||
|
||||
BigDecimal actualDistribution = allChannelStats.stream()
|
||||
.map(ChannelStats::getDistributionCost)
|
||||
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
||||
|
||||
// 나머지 비용 계산 (총 투자 - 실제 채널 배포 비용)
|
||||
BigDecimal remaining = totalInvestment.subtract(actualDistribution);
|
||||
|
||||
// 나머지 비용 분배: 경품 50%, 콘텐츠 제작 30%, 운영 20%
|
||||
BigDecimal prizeCost = remaining.multiply(BigDecimal.valueOf(0.50));
|
||||
BigDecimal contentCreation = remaining.multiply(BigDecimal.valueOf(0.30));
|
||||
BigDecimal operation = remaining.multiply(BigDecimal.valueOf(0.20));
|
||||
|
||||
InvestmentDetails investment = InvestmentDetails.builder()
|
||||
.total(totalInvestment)
|
||||
.contentCreation(contentCreation)
|
||||
.operation(operation)
|
||||
.distribution(actualDistribution)
|
||||
.prizeCost(prizeCost)
|
||||
.channelCost(actualDistribution) // 채널비용은 배포비용과 동일
|
||||
.build();
|
||||
|
||||
// 매출 분배: 직접 매출 70%, 예상 추가 매출 30% / 신규 고객 40%, 기존 고객 60%
|
||||
BigDecimal directSales = totalRevenue.multiply(BigDecimal.valueOf(0.70));
|
||||
BigDecimal expectedSales = totalRevenue.multiply(BigDecimal.valueOf(0.30));
|
||||
BigDecimal newCustomerRevenue = totalRevenue.multiply(BigDecimal.valueOf(0.40));
|
||||
BigDecimal existingCustomerRevenue = totalRevenue.multiply(BigDecimal.valueOf(0.60));
|
||||
|
||||
RevenueDetails revenue = RevenueDetails.builder()
|
||||
.total(totalRevenue)
|
||||
.directSales(directSales)
|
||||
.expectedSales(expectedSales)
|
||||
.newCustomerRevenue(newCustomerRevenue)
|
||||
.existingCustomerRevenue(existingCustomerRevenue)
|
||||
.brandValue(BigDecimal.ZERO) // 브랜드 가치는 별도 계산 필요 시 추가
|
||||
.build();
|
||||
|
||||
RoiCalculation roiCalc = RoiCalculation.builder()
|
||||
.netProfit(totalProfit)
|
||||
.roiPercentage(Math.round(roiPercentage * 10) / 10.0)
|
||||
.build();
|
||||
|
||||
int totalParticipants = allEvents.stream().mapToInt(EventStats::getTotalParticipants).sum();
|
||||
CostEfficiency efficiency = CostEfficiency.builder()
|
||||
.costPerParticipant(totalParticipants > 0 ? totalInvestment.doubleValue() / totalParticipants : 0.0)
|
||||
.revenuePerParticipant(totalParticipants > 0 ? totalRevenue.doubleValue() / totalParticipants : 0.0)
|
||||
.build();
|
||||
|
||||
RevenueProjection projection = includeProjection ? RevenueProjection.builder()
|
||||
.currentRevenue(totalRevenue)
|
||||
.projectedFinalRevenue(totalRevenue.multiply(BigDecimal.valueOf(1.2)))
|
||||
.confidenceLevel(85.0)
|
||||
.basedOn("Historical trend analysis")
|
||||
.build() : null;
|
||||
|
||||
List<UserRoiAnalyticsResponse.EventRoiSummary> eventRois = allEvents.stream()
|
||||
.map(event -> {
|
||||
Double eventRoi = event.getTotalInvestment().compareTo(BigDecimal.ZERO) > 0
|
||||
? event.getExpectedRevenue().subtract(event.getTotalInvestment())
|
||||
.divide(event.getTotalInvestment(), 4, RoundingMode.HALF_UP)
|
||||
.multiply(BigDecimal.valueOf(100)).doubleValue()
|
||||
: 0.0;
|
||||
|
||||
return UserRoiAnalyticsResponse.EventRoiSummary.builder()
|
||||
.eventId(event.getEventId())
|
||||
.eventTitle(event.getEventTitle())
|
||||
.totalInvestment(event.getTotalInvestment().doubleValue())
|
||||
.expectedRevenue(event.getExpectedRevenue().doubleValue())
|
||||
.roi(Math.round(eventRoi * 10) / 10.0)
|
||||
.status(event.getStatus())
|
||||
.build();
|
||||
})
|
||||
.sorted(Comparator.comparingDouble(UserRoiAnalyticsResponse.EventRoiSummary::getRoi).reversed())
|
||||
.collect(Collectors.toList());
|
||||
|
||||
// 전체 이벤트의 최소/최대 날짜로 period 계산
|
||||
PeriodInfo period = buildPeriodFromEvents(allEvents);
|
||||
|
||||
return UserRoiAnalyticsResponse.builder()
|
||||
.userId(userId)
|
||||
.period(period)
|
||||
.totalEvents(allEvents.size())
|
||||
.overallInvestment(investment)
|
||||
.overallRevenue(revenue)
|
||||
.overallRoi(roiCalc)
|
||||
.costEfficiency(efficiency)
|
||||
.projection(projection)
|
||||
.eventRois(eventRois)
|
||||
.lastUpdatedAt(LocalDateTime.now())
|
||||
.dataSource("cached")
|
||||
.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* 전체 이벤트의 생성/수정 시간 기반으로 period 계산
|
||||
*/
|
||||
private PeriodInfo buildPeriodFromEvents(List<EventStats> events) {
|
||||
LocalDateTime start = events.stream()
|
||||
.map(EventStats::getCreatedAt)
|
||||
.min(LocalDateTime::compareTo)
|
||||
.orElse(LocalDateTime.now());
|
||||
|
||||
LocalDateTime end = events.stream()
|
||||
.map(EventStats::getUpdatedAt)
|
||||
.max(LocalDateTime::compareTo)
|
||||
.orElse(LocalDateTime.now());
|
||||
|
||||
return PeriodInfo.builder()
|
||||
.startDate(start)
|
||||
.endDate(end)
|
||||
.durationDays((int) ChronoUnit.DAYS.between(start, end))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
+203
@@ -0,0 +1,203 @@
|
||||
package com.kt.event.analytics.service;
|
||||
|
||||
import com.kt.event.analytics.dto.response.*;
|
||||
import com.kt.event.analytics.entity.EventStats;
|
||||
import com.kt.event.analytics.entity.TimelineData;
|
||||
import com.kt.event.analytics.repository.EventStatsRepository;
|
||||
import com.kt.event.analytics.repository.TimelineDataRepository;
|
||||
import com.fasterxml.jackson.core.JsonProcessingException;
|
||||
import com.fasterxml.jackson.databind.ObjectMapper;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.data.redis.core.RedisTemplate;
|
||||
import org.springframework.stereotype.Service;
|
||||
import org.springframework.transaction.annotation.Transactional;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
import java.time.temporal.ChronoUnit;
|
||||
import java.util.*;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
/**
|
||||
* User Timeline Analytics Service
|
||||
*/
|
||||
@Slf4j
|
||||
@Service
|
||||
@RequiredArgsConstructor
|
||||
@Transactional(readOnly = true)
|
||||
public class UserTimelineAnalyticsService {
|
||||
|
||||
private final EventStatsRepository eventStatsRepository;
|
||||
private final TimelineDataRepository timelineDataRepository;
|
||||
private final RedisTemplate<String, String> redisTemplate;
|
||||
private final ObjectMapper objectMapper;
|
||||
|
||||
private static final String CACHE_KEY_PREFIX = "analytics:user:timeline:";
|
||||
private static final long CACHE_TTL = 1800;
|
||||
|
||||
public UserTimelineAnalyticsResponse getUserTimelineAnalytics(String userId, String interval,
|
||||
List<String> metrics, boolean refresh) {
|
||||
log.info("사용자 타임라인 분석 조회 시작: userId={}, interval={}, refresh={}", userId, interval, refresh);
|
||||
|
||||
String cacheKey = CACHE_KEY_PREFIX + userId + ":" + interval;
|
||||
|
||||
if (!refresh) {
|
||||
String cachedData = redisTemplate.opsForValue().get(cacheKey);
|
||||
if (cachedData != null) {
|
||||
try {
|
||||
return objectMapper.readValue(cachedData, UserTimelineAnalyticsResponse.class);
|
||||
} catch (JsonProcessingException e) {
|
||||
log.warn("캐시 역직렬화 실패: {}", e.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
List<EventStats> allEvents = eventStatsRepository.findAllByUserId(userId);
|
||||
if (allEvents.isEmpty()) {
|
||||
return buildEmptyResponse(userId, interval);
|
||||
}
|
||||
|
||||
List<String> eventIds = allEvents.stream().map(EventStats::getEventId).collect(Collectors.toList());
|
||||
List<TimelineData> allTimelineData = timelineDataRepository.findByEventIdInOrderByTimestampAsc(eventIds);
|
||||
|
||||
UserTimelineAnalyticsResponse response = buildTimelineResponse(userId, allEvents, allTimelineData, interval);
|
||||
|
||||
try {
|
||||
String jsonData = objectMapper.writeValueAsString(response);
|
||||
redisTemplate.opsForValue().set(cacheKey, jsonData, CACHE_TTL, TimeUnit.SECONDS);
|
||||
} catch (Exception e) {
|
||||
log.warn("캐시 저장 실패: {}", e.getMessage());
|
||||
}
|
||||
|
||||
return response;
|
||||
}
|
||||
|
||||
private UserTimelineAnalyticsResponse buildEmptyResponse(String userId, String interval) {
|
||||
LocalDateTime now = LocalDateTime.now();
|
||||
return UserTimelineAnalyticsResponse.builder()
|
||||
.userId(userId)
|
||||
.period(PeriodInfo.builder()
|
||||
.startDate(now)
|
||||
.endDate(now)
|
||||
.durationDays(0)
|
||||
.build())
|
||||
.totalEvents(0)
|
||||
.interval(interval != null ? interval : "daily")
|
||||
.dataPoints(new ArrayList<>())
|
||||
.trend(TrendAnalysis.builder().overallTrend("stable").build())
|
||||
.peakTime(PeakTimeInfo.builder().build())
|
||||
.lastUpdatedAt(LocalDateTime.now())
|
||||
.dataSource("empty")
|
||||
.build();
|
||||
}
|
||||
|
||||
private UserTimelineAnalyticsResponse buildTimelineResponse(String userId, List<EventStats> allEvents,
|
||||
List<TimelineData> allTimelineData, String interval) {
|
||||
Map<LocalDateTime, TimelineDataPoint> aggregatedData = new LinkedHashMap<>();
|
||||
|
||||
for (TimelineData data : allTimelineData) {
|
||||
LocalDateTime key = normalizeTimestamp(data.getTimestamp(), interval);
|
||||
aggregatedData.computeIfAbsent(key, k -> TimelineDataPoint.builder()
|
||||
.timestamp(k)
|
||||
.participants(0)
|
||||
.views(0)
|
||||
.engagement(0)
|
||||
.conversions(0)
|
||||
.build());
|
||||
|
||||
TimelineDataPoint point = aggregatedData.get(key);
|
||||
point.setParticipants(point.getParticipants() + data.getParticipants());
|
||||
point.setViews(point.getViews() + data.getViews());
|
||||
point.setEngagement(point.getEngagement() + data.getEngagement());
|
||||
point.setConversions(point.getConversions() + data.getConversions());
|
||||
}
|
||||
|
||||
List<TimelineDataPoint> dataPoints = new ArrayList<>(aggregatedData.values());
|
||||
|
||||
TrendAnalysis trend = analyzeTrend(dataPoints);
|
||||
PeakTimeInfo peakTime = findPeakTime(dataPoints);
|
||||
|
||||
return UserTimelineAnalyticsResponse.builder()
|
||||
.userId(userId)
|
||||
.period(buildPeriodFromEvents(allEvents))
|
||||
.totalEvents(allEvents.size())
|
||||
.interval(interval != null ? interval : "daily")
|
||||
.dataPoints(dataPoints)
|
||||
.trend(trend)
|
||||
.peakTime(peakTime)
|
||||
.lastUpdatedAt(LocalDateTime.now())
|
||||
.dataSource("cached")
|
||||
.build();
|
||||
}
|
||||
|
||||
private LocalDateTime normalizeTimestamp(LocalDateTime timestamp, String interval) {
|
||||
switch (interval != null ? interval.toLowerCase() : "daily") {
|
||||
case "hourly":
|
||||
return timestamp.truncatedTo(ChronoUnit.HOURS);
|
||||
case "weekly":
|
||||
return timestamp.truncatedTo(ChronoUnit.DAYS).minusDays(timestamp.getDayOfWeek().getValue() - 1);
|
||||
case "monthly":
|
||||
return timestamp.withDayOfMonth(1).truncatedTo(ChronoUnit.DAYS);
|
||||
case "daily":
|
||||
default:
|
||||
return timestamp.truncatedTo(ChronoUnit.DAYS);
|
||||
}
|
||||
}
|
||||
|
||||
private TrendAnalysis analyzeTrend(List<TimelineDataPoint> dataPoints) {
|
||||
if (dataPoints.size() < 2) {
|
||||
return TrendAnalysis.builder().overallTrend("stable").build();
|
||||
}
|
||||
|
||||
int firstHalf = dataPoints.subList(0, dataPoints.size() / 2).stream()
|
||||
.mapToInt(TimelineDataPoint::getParticipants).sum();
|
||||
int secondHalf = dataPoints.subList(dataPoints.size() / 2, dataPoints.size()).stream()
|
||||
.mapToInt(TimelineDataPoint::getParticipants).sum();
|
||||
|
||||
double growthRate = firstHalf > 0 ? ((double) (secondHalf - firstHalf) / firstHalf) * 100 : 0.0;
|
||||
String trend = growthRate > 5 ? "increasing" : (growthRate < -5 ? "decreasing" : "stable");
|
||||
|
||||
return TrendAnalysis.builder()
|
||||
.overallTrend(trend)
|
||||
.build();
|
||||
}
|
||||
|
||||
private PeakTimeInfo findPeakTime(List<TimelineDataPoint> dataPoints) {
|
||||
if (dataPoints.isEmpty()) {
|
||||
return PeakTimeInfo.builder().build();
|
||||
}
|
||||
|
||||
TimelineDataPoint peak = dataPoints.stream()
|
||||
.max(Comparator.comparingInt(TimelineDataPoint::getParticipants))
|
||||
.orElse(null);
|
||||
|
||||
return peak != null ? PeakTimeInfo.builder()
|
||||
.timestamp(peak.getTimestamp())
|
||||
.metric("participants")
|
||||
.value(peak.getParticipants())
|
||||
.description(peak.getViews() + " views at peak time")
|
||||
.build() : PeakTimeInfo.builder().build();
|
||||
}
|
||||
|
||||
/**
|
||||
* 전체 이벤트의 생성/수정 시간 기반으로 period 계산
|
||||
*/
|
||||
private PeriodInfo buildPeriodFromEvents(List<EventStats> events) {
|
||||
LocalDateTime start = events.stream()
|
||||
.map(EventStats::getCreatedAt)
|
||||
.min(LocalDateTime::compareTo)
|
||||
.orElse(LocalDateTime.now());
|
||||
|
||||
LocalDateTime end = events.stream()
|
||||
.map(EventStats::getUpdatedAt)
|
||||
.max(LocalDateTime::compareTo)
|
||||
.orElse(LocalDateTime.now());
|
||||
|
||||
return PeriodInfo.builder()
|
||||
.startDate(start)
|
||||
.endDate(end)
|
||||
.durationDays((int) ChronoUnit.DAYS.between(start, end))
|
||||
.build();
|
||||
}
|
||||
}
|
||||
@@ -4,7 +4,7 @@ spring:
|
||||
|
||||
# Database
|
||||
datasource:
|
||||
url: jdbc:${DB_KIND:postgresql}://${DB_HOST:localhost}:${DB_PORT:5432}/${DB_NAME:analytics_db}
|
||||
url: jdbc:postgresql://${DB_HOST:4.230.49.9}:${DB_PORT:5432}/${DB_NAME:analytics_db}
|
||||
username: ${DB_USERNAME:analytics_user}
|
||||
password: ${DB_PASSWORD:analytics_pass}
|
||||
driver-class-name: org.postgresql.Driver
|
||||
@@ -23,6 +23,7 @@ spring:
|
||||
hibernate:
|
||||
format_sql: true
|
||||
use_sql_comments: true
|
||||
dialect: org.hibernate.dialect.PostgreSQLDialect
|
||||
hibernate:
|
||||
ddl-auto: ${DDL_AUTO:update}
|
||||
|
||||
@@ -46,11 +47,13 @@ spring:
|
||||
enabled: ${KAFKA_ENABLED:true}
|
||||
bootstrap-servers: ${KAFKA_BOOTSTRAP_SERVERS:20.249.182.13:9095,4.217.131.59:9095}
|
||||
consumer:
|
||||
group-id: ${KAFKA_CONSUMER_GROUP_ID:analytics-service}
|
||||
group-id: ${KAFKA_CONSUMER_GROUP_ID:analytics-service-consumers-v3}
|
||||
auto-offset-reset: earliest
|
||||
enable-auto-commit: true
|
||||
key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
|
||||
value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
|
||||
properties:
|
||||
auto.offset.reset: earliest
|
||||
producer:
|
||||
key-serializer: org.apache.kafka.common.serialization.StringSerializer
|
||||
value-serializer: org.apache.kafka.common.serialization.StringSerializer
|
||||
@@ -72,6 +75,12 @@ spring:
|
||||
# Server
|
||||
server:
|
||||
port: ${SERVER_PORT:8086}
|
||||
servlet:
|
||||
encoding:
|
||||
charset: UTF-8
|
||||
enabled: true
|
||||
force: true
|
||||
context-path: /api/v1/analytics
|
||||
|
||||
# JWT
|
||||
jwt:
|
||||
@@ -81,7 +90,11 @@ jwt:
|
||||
|
||||
# CORS Configuration
|
||||
cors:
|
||||
allowed-origins: ${CORS_ALLOWED_ORIGINS:http://localhost:*}
|
||||
allowed-origins: ${CORS_ALLOWED_ORIGINS:http://localhost:8081,http://localhost:8082,http://localhost:8083,http://localhost:8084,http://kt-event-marketing.20.214.196.128.nip.io}
|
||||
allowed-methods: ${CORS_ALLOWED_METHODS:GET,POST,PUT,DELETE,OPTIONS,PATCH}
|
||||
allowed-headers: ${CORS_ALLOWED_HEADERS:*}
|
||||
allow-credentials: ${CORS_ALLOW_CREDENTIALS:true}
|
||||
max-age: ${CORS_MAX_AGE:3600}
|
||||
|
||||
# Actuator
|
||||
management:
|
||||
|
||||
Reference in New Issue
Block a user