feat: 티켓 시스템 구현

src/main/java/hanium/modic/backend/common/error/ErrorCode.java

@@ -73,11 +73,9 @@ public enum ErrorCode {
 	AI_REQUEST_NOT_FOUND(HttpStatus.NOT_FOUND, "A-001", "해당 AI 요청을 찾을 수 없습니다."),
 	CREATED_AI_IMAGE_NOT_FOUND(HttpStatus.NOT_FOUND, "A-002", "생성된 AI 이미지를 찾을 수 없습니다."),
 	AI_IMAGE_DATA_INCONSISTENCY(HttpStatus.INTERNAL_SERVER_ERROR, "A-003", "AI 이미지 데이터 일관성 오류가 발생했습니다."),
-
-	// AI Image Permission
-	AI_IMAGE_PERMISSION_NOT_FOUND(HttpStatus.FORBIDDEN, "AI-003", "AI 이미지 생성 권한이 없습니다."),
-	AI_IMAGE_PERMISSION_ALREADY_EXISTS(HttpStatus.CONFLICT, "AI-004", "이미 AI 이미지 생성 권한이 존재합니다."),
-	AI_IMAGE_PERMISSION_ENTITY_NOT_FOUND(HttpStatus.NOT_FOUND, "AI-005", "해당 AI 이미지 생성 권한을 찾을 수 없습니다."),
+	AI_IMAGE_PERMISSION_NOT_FOUND(HttpStatus.FORBIDDEN, "A-004", "AI 이미지 생성 권한이 없습니다."),
+	AI_REQUEST_TICKET_PROCESSING_FAIL_EXCEPTION(HttpStatus.INTERNAL_SERVER_ERROR, "A-005", "티켓 처리에 실패했습니다."),
+	AI_REQUEST_TICKET_NOT_ENOUGH_EXCEPTION(HttpStatus.BAD_REQUEST, "AI-006", "티켓이 부족합니다."),
 	;
 
 	private final HttpStatus status;

src/main/java/hanium/modic/backend/common/redis/distributedLock/LockManager.java

@@ -30,6 +30,7 @@ public class LockManager {
 	private static final long postLikeLeaseTime = 1L; // 좋아요 락 유지 시간(1초)
 	private static final String REDISSON_USER_LOCK_PREFIX = "USER_LOCK:";
 	private static final String REDISSON_POST_LIKE_LOCK_PREFIX = "POST_LIKE:";
+	private static final String REDISSON_USER_TICKET_LOCK_PREFIX = "USER_TICKET_LOCK:";
 
 	// 유저 단일 락
 	public void userLock(
@@ -118,4 +119,30 @@ public void postLikeLock(
 			}
 		}
 	}
+
+	// AI 요청 티켓 락
+	public void aiRequestTicketLock(
+		final Long userId,
+		Runnable block
+	) throws LockException {
+		String key = REDISSON_USER_TICKET_LOCK_PREFIX + userId;
+		RLock rLock = redissonClient.getLock(key);
+
+		try {
+			boolean available = rLock.tryLock(waitTime, leaseTime, timeUnit);
+			if (!available) {
+				throw new LockException(new InterruptedException("유저 티켓 락 획득 실패"));
+			}
+
+			aopForTransaction.proceed(block); // lock 범위 안에서 트랜잭션 적용 후 로직 처리
+		} catch (InterruptedException e) {
+			throw new LockException(e); // 락 획득 실패시 Exception 발생
+		} finally {
+			try {
+				rLock.unlock();
+			} catch (IllegalMonitorStateException e) {
+				log.info("유저 티켓 분산 락이 이미 해제되었습니다. :key({})", key);
+			}
+		}
+	}
 }

src/main/java/hanium/modic/backend/domain/ai/domain/AiRequestTicketEntity.java

@@ -0,0 +1,68 @@
+package hanium.modic.backend.domain.ai.domain;
+
+import static hanium.modic.backend.common.error.ErrorCode.*;
+import static hanium.modic.backend.domain.ai.enums.AiRequestTicketConstants.*;
+
+import java.time.LocalDateTime;
+
+import hanium.modic.backend.common.entity.BaseEntity;
+import hanium.modic.backend.common.error.exception.AppException;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Table(name = "ai_request_tickets")
+@Entity
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class AiRequestTicketEntity extends BaseEntity {
+
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	private Long id;
+
+	@Column(name = "user_id", nullable = false, unique = true)
+	private Long userId;
+
+	@Column(name = "ticket_count", nullable = false)
+	private Integer ticketCount;
+
+	@Column(name = "last_issued_at", nullable = false)
+	private LocalDateTime lastIssuedAt;
+
+	@Builder
+	private AiRequestTicketEntity(Long userId) {
+		this.userId = userId;
+		this.ticketCount = FREE_TICKET_COUNT_PER_DAY;
+		this.lastIssuedAt = LocalDateTime.now();
+	}
+
+	// 잔여 티켓 차감
+	public void decreaseTicket() {
+		if (this.ticketCount <= MINIMUM_TICKET_COUNT) {
+			throw new AppException(AI_REQUEST_TICKET_NOT_ENOUGH_EXCEPTION);
+		}
+		this.ticketCount--;
+	}
+
+	// 티켓을 초기화
+	public void resetTickets() {
+		this.ticketCount = FREE_TICKET_COUNT_PER_DAY;
+		this.lastIssuedAt = LocalDateTime.now();
+	}
+
+	public boolean hasTickets() {
+		return this.ticketCount > MINIMUM_TICKET_COUNT;
+	}
+
+	public boolean isTicketExpired() {
+		return LocalDateTime.now().isAfter(this.lastIssuedAt.plusDays(1));
+	}
+}

src/main/java/hanium/modic/backend/domain/ai/enums/AiRequestTicketConstants.java

@@ -0,0 +1,12 @@
+package hanium.modic.backend.domain.ai.enums;
+
+public final class AiRequestTicketConstants {
+
+	private AiRequestTicketConstants() {
+		// Prevent instantiation
+	}
+
+	public static final int FREE_TICKET_COUNT_PER_DAY = 3;
+
+	public static final int MINIMUM_TICKET_COUNT = 0;
+}

src/main/java/hanium/modic/backend/domain/ai/repository/AiRequestTicketRepository.java

@@ -0,0 +1,12 @@
+package hanium.modic.backend.domain.ai.repository;
+
+import java.util.Optional;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import hanium.modic.backend.domain.ai.domain.AiRequestTicketEntity;
+
+public interface AiRequestTicketRepository extends JpaRepository<AiRequestTicketEntity, Long> {
+
+	Optional<AiRequestTicketEntity> findByUserId(Long userId);
+}

src/main/java/hanium/modic/backend/domain/ai/service/AiImageGenerationService.java

@@ -1,5 +1,7 @@
 package hanium.modic.backend.domain.ai.service;
 
+import static hanium.modic.backend.common.error.ErrorCode.*;
+
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -20,8 +22,11 @@
 import hanium.modic.backend.domain.ai.repository.AiRequestRepository;
 import hanium.modic.backend.domain.ai.repository.CreatedAiImageRepository;
 import hanium.modic.backend.domain.image.domain.ImagePrefix;
+import hanium.modic.backend.domain.post.entity.PostEntity;
 import hanium.modic.backend.domain.post.entity.PostImageEntity;
+import hanium.modic.backend.domain.post.repository.PostEntityRepository;
 import hanium.modic.backend.domain.post.repository.PostImageEntityRepository;
+import hanium.modic.backend.domain.user.service.UserCoinService;
 import hanium.modic.backend.web.ai.dto.response.MyGeneratedAiImageResponse;
 import hanium.modic.backend.web.ai.dto.response.RequestAiImageGenerationResponse;
 import lombok.AccessLevel;
@@ -35,16 +40,25 @@
 public class AiImageGenerationService {
 
 	private final AiImageService aiImageService;
+	private final AiRequestTicketService aiRequestTicketService;
 	private final MessageQueueService messageQueueService;
 	private final PostImageEntityRepository postImageEntityRepository;
 	private final AiRequestRepository aiRequestRepository;
 	private final CreatedAiImageRepository createdAiImageRepository;
 	private final CreatedAiImageService createdAiImageService;
 	private final AiImagePermissionRepository aiImagePermissionRepository;
+	private final UserCoinService userCoinService;
+	private final PostEntityRepository postEntityRepository;
 
 	@Transactional
-	public RequestAiImageGenerationResponse processImageGeneration(ImagePrefix imageUsagePurpose, String fileName,
-		String imagePath, Long postId, Long userId) {
+	public RequestAiImageGenerationResponse processImageGeneration(
+		ImagePrefix imageUsagePurpose,
+		String fileName,
+		String imagePath,
+		Long postId,
+		Long userId,
+		Boolean useTicket
+	) {
 		// 사용자 권한 검증
 		validateAiRequestPermission(userId, postId);
 
@@ -57,6 +71,18 @@ public RequestAiImageGenerationResponse processImageGeneration(ImagePrefix image
 		AiRequestEntity aiRequestEntity = aiImageService.saveImage(imageUsagePurpose, fileName, imagePath, userId,
 			postId);
 
+		// 포스트 조회
+		PostEntity post = postEntityRepository.findById(postId)
+			.orElseThrow(() -> new AppException(POST_NOT_FOUND_EXCEPTION));
+
+		// 결제 처리
+		if (useTicket) {
+			aiRequestTicketService.useTicket(userId);
+		} else {
+			// Todo : 상업용, 비상업용에 대해 로직 처리 필요
+			userCoinService.consumeCoin(userId, post.getCommercialPrice());
+		}
+
 		// MQ에 이미지 생성 요청 전송
 		messageQueueService.sendImageGenerationRequest(
 			aiRequestEntity.getRequestId(),

src/main/java/hanium/modic/backend/domain/ai/service/AiRequestTicketService.java

@@ -0,0 +1,81 @@
+package hanium.modic.backend.domain.ai.service;
+
+import static hanium.modic.backend.common.error.ErrorCode.*;
+
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import hanium.modic.backend.common.error.exception.AppException;
+import hanium.modic.backend.common.error.exception.LockException;
+import hanium.modic.backend.common.redis.distributedLock.LockManager;
+import hanium.modic.backend.domain.ai.domain.AiRequestTicketEntity;
+import hanium.modic.backend.domain.ai.repository.AiRequestTicketRepository;
+import hanium.modic.backend.web.ai.dto.response.GetTicketInformationResponse;
+import lombok.RequiredArgsConstructor;
+
+@Service
+@RequiredArgsConstructor
+public class AiRequestTicketService {
+
+	private final AiRequestTicketRepository aiRequestTicketRepository;
+	private final LockManager lockManager;
+
+	// 티켓 관련 정보 조회
+	@Transactional(readOnly = true)
+	public GetTicketInformationResponse getTicketInformation(Long userId) {
+		AiRequestTicketEntity ticket = getTicketEntity(userId);
+		return GetTicketInformationResponse.of(ticket.getTicketCount(), ticket.getLastIssuedAt().plusDays(1));
+	}
+
+	// 티켓 엔티티 조회, 만료되면 갱신
+	@Transactional
+	public AiRequestTicketEntity getTicketEntity(Long userId) {
+		return aiRequestTicketRepository.findByUserId(userId)
+			.map(this::refreshTicketIfExpired)
+			.orElseGet(() -> createInitialTicket(userId));
+	}
+
+	// 티켓 한 개 소모, 잔여 티켓이 없으면 에러
+	@Transactional
+	public void useTicket(Long userId) {
+		try {
+			lockManager.aiRequestTicketLock(userId, () -> {
+				// 티켓 조회, 티켓 만료 체크, 만료되면 티켓 초기화, 재진입 가능 락이라 refreshTicketsIfExpired 메서드에서 락 호출 가능.
+				AiRequestTicketEntity userTicket = getTicketEntity(userId);
+
+
+				// 티켓 차감, 잔여 티켓이 없으면 예외 발생
+				userTicket.decreaseTicket();
+				aiRequestTicketRepository.save(userTicket);
+			});
+		} catch (LockException e) {
+			throw new AppException(AI_REQUEST_TICKET_PROCESSING_FAIL_EXCEPTION);
+		}
+	}
+
+	// 티켓이 만료되면 초기화
+	private AiRequestTicketEntity refreshTicketIfExpired(AiRequestTicketEntity userTicket) {
+		try {
+			lockManager.aiRequestTicketLock(userTicket.getUserId(), () -> {
+				if (userTicket.isTicketExpired()) {
+					userTicket.resetTickets();
+				}
+				aiRequestTicketRepository.save(userTicket);
+			});
+		} catch (LockException e) {
+			throw new AppException(AI_REQUEST_TICKET_PROCESSING_FAIL_EXCEPTION);
+		}
+
+		return userTicket;
+	}
+
+	// 사용자가 티켓을 생성 및 저장
+	@Transactional
+	public AiRequestTicketEntity createInitialTicket(Long userId) {
+		AiRequestTicketEntity newUserTicket = AiRequestTicketEntity.builder()
+			.userId(userId)
+			.build();
+
+		return aiRequestTicketRepository.save(newUserTicket);
+	}
+}