Merge pull request 'Test' (#452 ) from test into main

Reviewed-on: #452
Merge pull request 'Test' (#451 ) from test into main
2026-09-18 05:56:04 +00:00 · 2026-09-18 02:15:25 +00:00 · 2026-09-15 01:56:13 +00:00 · 2026-09-10 07:58:31 +00:00 · 2026-08-20 10:04:02 +00:00 · 2026-08-19 08:56:01 +00:00
54 changed files with 9 additions and 9043 deletions
@@ -1,364 +0,0 @@
-# 선물하기 클라이언트 API 요약
-
-## 문서 목적
-
- 이 문서는 클라이언트 구현 프롬프트 작성용 빠른 참조다.
- 상세 request/response 계약은 `prd.md`의 `8. API 계약`을 기준으로 한다.
- 여기서는 사용자 역할별 URI, 역할, 핵심 request/response 필드만 요약한다.
-
-## 문서 분리 결정
-
-PRD에는 상세 API 계약, request/response 예시, 요구사항을 유지한다. 클라이언트 프롬프트용 역할별 인벤토리는 별도 문서로 둔다.
-
- 이유: PRD에 같은 URI 정보를 역할별로 다시 넣으면 상세 계약과 요약표를 동시에 갱신해야 한다.
- 기준: PRD는 제품 요구사항과 API 계약의 원본, 이 문서는 클라이언트 구현을 위한 탐색용 색인이다.
-
-## 공통/조회 API
-
-| 사용자 | Method | URI | 역할 | Request | Response |
-|---|---:|---|---|---|---|
-| 비회원/회원 | GET | `/api/v2/gifts/form-options` | 선물 신청 폼에 필요한 활성 카테고리와 사이즈별 가격 옵션을 조회한다. | 없음 | `sizes[]`, `categories[]` |
-| 팬/크리에이터 | GET | `/api/v2/gifts?type=ALL&page=0&size=20` | 내 선물함 목록을 조회하고 `type=ALL|SENT|RECEIVED`로 전체/보낸/받은 선물을 필터링한다. | query: `type`, `page`, `size` | `items[]`, `page`, `size`, `hasNext` |
-| 팬/크리에이터 | GET | `/api/v2/gifts/{applicationNo}` | 선물 상세를 조회하며 로그인 회원이 팬인지 크리에이터인지에 따라 노출 정보와 CTA flag가 달라진다. | path: `applicationNo` | `applicationNo`, `direction`, `status`, `statusName`, `giftInfo`, `senderInfo`, `recipientAddress`, `mailbox`, `trackingRequired`, `recipientAddressRequired`, `delivery`, `statusTimeline`, `review` |
-
-## 팬 API
-
-| 사용자 | Method | URI | 역할 | Request | Response |
-|---|---:|---|---|---|---|
-| 팬 | POST | `/api/v2/gifts` | 크리에이터에게 선물을 신청하고 최종 결제 금액만큼 캔을 차감한다. | body: `recipientMemberId`, `senderName`, `senderPhoneNumber`, `senderZipCode`, `senderAddress`, `senderAddressDetail`, `sizeCode`, `categoryId`, `senderTermsAgreed`, `senderPrivacyAgreed`, `damageWaiverAgreed` | `applicationNo`, `status`, `statusName`, `priceCan`, `trackingDeadlineAt` |
-| 팬 | POST | `/api/v2/gifts/{applicationNo}/cancel` | 운송장 등록 전 선물 신청을 취소하고 전액 환불한다. | path: `applicationNo` | `applicationNo`, `status`, `statusName`, `priceCan`, `canceledAt` |
-| 팬 | POST | `/api/v2/gifts/{applicationNo}/tracking` | 발송 후 택배사와 운송장 번호를 등록한다. | path: `applicationNo`, body: `courierCompanyName`, `trackingNumber` | `applicationNo`, `status`, `statusName`, `courierCompanyName`, `trackingNumber`, `trackingRegisteredAt`, `recipientAddressDeadlineAt` |
-| 팬 | POST | `/api/v2/gifts/{applicationNo}/review` | 전달 완료된 선물에 리뷰를 작성한다. | path: `applicationNo`, body: `rating`, `keywords`, `comment` | `reviewId`, `applicationNo`, `rating`, `keywords`, `comment`, `createdAt` |
-
-## 크리에이터 API
-
-| 사용자 | Method | URI | 역할 | Request | Response |
-|---|---:|---|---|---|---|
-| 크리에이터 | POST | `/api/v2/gifts/{applicationNo}/recipient-address` | 운송장 등록 이후 배송지와 수령 약관 동의를 등록한다. | path: `applicationNo`, body: `recipientName`, `recipientPhoneNumber`, `recipientZipCode`, `recipientAddress`, `recipientAddressDetail`, `recipientTermsAgreed`, `recipientPrivacyAgreed` | `applicationNo`, `status`, `statusName`, `recipientAddressRegisteredAt` |
-| 크리에이터 | POST | `/api/v2/gifts/{applicationNo}/delivery-complete` | 검수 완료된 선물을 직접 수령 완료 처리한다. | path: `applicationNo` | `applicationNo`, `status`, `statusName`, `deliveredAt` |
-
-## 관리자 API
-
-| 사용자 | Method | URI | 역할 | Request | Response |
-|---|---:|---|---|---|---|
-| 관리자 | GET | `/api/v2/admin/gift-categories` | 선물 카테고리 목록을 조회한다. | 없음 | `AdminGiftCategoryResponse[]` |
-| 관리자 | GET | `/api/v2/admin/gifts` | 전체 선물함 목록을 조회하고 상태/신청번호/닉네임으로 검색한다. | query: `status`, `applicationNo`, `nickname`, `page`, `size` | `totalCount`, `items[]`, `page`, `size`, `hasNext` |
-| 관리자 | GET | `/api/v2/admin/gifts/{applicationNo}` | 선물 상세와 발송인/수취인 개인정보, 상품/배송/상태 정보를 조회한다. | path: `applicationNo` | `applicationNo`, `senderInfo`, `recipientInfo`, `productInfo`, `inboundDeliveryInfo`, `status`, `statusName`, `availableActions` |
-| 관리자 | POST | `/api/v2/admin/gift-categories` | 선물 카테고리를 등록한다. | body: `classificationNumber`, `categoryCode`, `name`, `receiptCode`, `representativeItem`, `requiresDamageWaiver`, `isActive` | `categoryId`, `classificationNumber`, `categoryCode`, `name`, `receiptCode`, `representativeItem`, `requiresDamageWaiver`, `isActive` |
-| 관리자 | PUT | `/api/v2/admin/gift-categories/{categoryId}` | 선물 카테고리를 수정한다. | path: `categoryId`, body: `classificationNumber`, `categoryCode`, `name`, `receiptCode`, `representativeItem`, `requiresDamageWaiver`, `isActive` | `categoryId`, `classificationNumber`, `categoryCode`, `name`, `receiptCode`, `representativeItem`, `requiresDamageWaiver`, `isActive` |
-| 관리자 | DELETE | `/api/v2/admin/gift-categories/{categoryId}` | 선물 카테고리를 비활성화한다. | path: `categoryId` | `categoryId`, `classificationNumber`, `categoryCode`, `name`, `receiptCode`, `representativeItem`, `requiresDamageWaiver`, `isActive=false` |
-| 관리자 | GET | `/api/v2/admin/gift-size-prices` | 사이즈별 기본가와 판매가를 조회한다. | 없음 | `AdminGiftSizePriceResponse[]` |
-| 관리자 | PUT | `/api/v2/admin/gift-size-prices/{sizeCode}` | 사이즈별 기본가와 판매가를 수정한다. | path: `sizeCode`, body: `basePriceCan`, `salePriceCan`, `isActive` | `sizeCode`, `name`, `basePriceCan`, `salePriceCan`, `isActive` |
-| 관리자 | POST | `/api/v2/admin/gifts/{applicationNo}/arrive-mailbox` | 발송 확인 선물을 사서함 도착 처리한다. | path: `applicationNo` | `applicationNo`, `status`, `statusName`, `occurredAt` |
-| 관리자 | POST | `/api/v2/admin/gifts/{applicationNo}/complete-inspection` | 사서함 도착 선물을 검수 완료 처리한다. | path: `applicationNo` | `applicationNo`, `status`, `statusName`, `occurredAt` |
-| 관리자 | POST | `/api/v2/admin/gifts/{applicationNo}/mark-undeliverable` | 진행 중 선물을 전달 불가 처리하고 사유를 저장한다. | path: `applicationNo`, body: `reason` | `applicationNo`, `status`, `statusName`, `occurredAt` |
-| 관리자 | POST | `/api/v2/admin/gifts/{applicationNo}/complete-delivery` | 검수 완료 선물을 운영자가 전달 완료 처리한다. | path: `applicationNo` | `applicationNo`, `status`, `statusName`, `occurredAt` |
-
-관리자 응답 DTO 요약:
-
- `AdminGiftCategoryResponse`: `categoryId`, `classificationNumber`, `categoryCode`, `name`, `receiptCode`, `representativeItem`, `requiresDamageWaiver`, `isActive`
- `AdminGiftListResponse`: `totalCount`, `items`, `page`, `size`, `hasNext`
- `AdminGiftListItemResponse`: `applicationNo`, `senderNickname`, `recipientNickname`, `sizeCode`, `sizeName`, `categoryName`, `classificationNumber`, `courierCompanyName`, `trackingNumber`, `status`, `statusName`, `availableActions`
- `AdminGiftDetailResponse`: `applicationNo`, `senderInfo`, `recipientInfo`, `productInfo`, `inboundDeliveryInfo`, `status`, `statusName`, `availableActions`
- `AdminGiftSizePriceResponse`: `sizeCode`, `name`, `basePriceCan`, `salePriceCan`, `isActive`
- `AdminGiftOperationStatusResponse`: `applicationNo`, `status`, `statusName`, `occurredAt`
-
-## Kotlin DTO 형태
-
-아래는 JSON으로 변환되기 직전의 API request/response `data class` 형태다. `companion object` 변환 함수는 클라이언트 입력/출력 형태와 직접 관련이 없어 생략했다. 응답 시각 필드는 UTC ISO 문자열이다. 예: `2026-09-30T12:00:00Z`.
-
-### 사용자 Request DTO
-
-```kotlin
-data class GiftApplicationRequest(
-    val recipientMemberId: Long,
-    val senderName: String,
-    val senderPhoneNumber: String,
-    val senderZipCode: String,
-    val senderAddress: String,
-    val senderAddressDetail: String?,
-    val sizeCode: GiftSize,
-    val categoryId: Long,
-    val senderTermsAgreed: Boolean,
-    val senderPrivacyAgreed: Boolean,
-    val damageWaiverAgreed: Boolean
-)
-
-data class GiftTrackingRegistrationRequest(
-    val courierCompanyName: String,
-    val trackingNumber: String
-)
-
-data class GiftRecipientAddressRegistrationRequest(
-    val recipientName: String,
-    val recipientPhoneNumber: String,
-    val recipientZipCode: String,
-    val recipientAddress: String,
-    val recipientAddressDetail: String?,
-    val recipientTermsAgreed: Boolean,
-    val recipientPrivacyAgreed: Boolean
-)
-
-data class GiftReviewRequest(
-    val rating: Int,
-    val keywords: List<String>,
-    val comment: String?
-)
-```
-
-### 사용자 Response DTO
-
-```kotlin
-data class GiftFormOptionsResponse(
-    val sizes: List<GiftSizeOptionResponse>,
-    val categories: List<GiftCategoryOptionResponse>
-)
-
-data class GiftSizeOptionResponse(
-    val sizeCode: String,
-    val name: String,
-    val basePriceCan: Int,
-    val salePriceCan: Int
-)
-
-data class GiftCategoryOptionResponse(
-    val categoryId: Long,
-    val name: String,
-    val requiresDamageWaiver: Boolean
-)
-
-// name은 사용자 폼 옵션에서만 "분류명/대표품목" 형태로 조합된다.
-
-data class GiftListResponse(
-    val totalCount: Long,
-    val items: List<GiftListItemResponse>,
-    val page: Int,
-    val size: Int,
-    val hasNext: Boolean
-)
-
-data class GiftListItemResponse(
-    val applicationNo: String,
-    val direction: String,
-    val status: String,
-    val statusName: String,
-    val priceCan: Int,
-    val categoryName: String,
-    val sizeName: String,
-    val createdAt: String?
-)
-
-data class GiftDetailResponse(
-    val applicationNo: String,
-    val direction: String,
-    val status: String,
-    val statusName: String,
-    val giftInfo: GiftDetailInfoResponse,
-    val senderInfo: GiftAddressResponse?,
-    val recipientAddress: GiftAddressResponse?,
-    val mailbox: GiftMailboxResponse?,
-    val trackingRequired: Boolean,
-    val recipientAddressRequired: Boolean,
-    val recipientAddressDeadlineAt: String?,
-    val delivery: GiftDeliveryInfoResponse,
-    val statusTimeline: List<GiftStatusTimelineResponse>
-)
-
-data class GiftDetailInfoResponse(
-    val recipientCreatorNickname: String?,
-    val senderNickname: String?,
-    val sizeName: String,
-    val categoryName: String,
-    val applicationNo: String?,
-    val paidCan: Int?,
-    val tracking: String?,
-    val shippingRequestedAt: String?
-)
-
-data class GiftAddressResponse(
-    val name: String,
-    val phoneNumber: String,
-    val address: String
-)
-
-data class GiftMailboxResponse(
-    val name: String,
-    val address: String,
-    val phoneNumber: String
-)
-
-data class GiftDeliveryInfoResponse(
-    val canceledAt: String?,
-    val undeliverableAt: String?,
-    val undeliverableReason: String?
-)
-
-data class GiftStatusTimelineResponse(
-    val status: String,
-    val statusName: String,
-    val occurredAt: String?
-)
-
-data class GiftApplicationResponse(
-    val applicationNo: String,
-    val status: String,
-    val statusName: String,
-    val priceCan: Int,
-    val trackingDeadlineAt: String
-)
-
-data class GiftCancellationResponse(
-    val applicationNo: String,
-    val status: String,
-    val statusName: String,
-    val priceCan: Int,
-    val canceledAt: String
-)
-
-data class GiftTrackingRegistrationResponse(
-    val applicationNo: String,
-    val status: String,
-    val statusName: String,
-    val courierCompanyName: String,
-    val trackingNumber: String,
-    val trackingRegisteredAt: String,
-    val recipientAddressDeadlineAt: String
-)
-
-data class GiftRecipientAddressRegistrationResponse(
-    val applicationNo: String,
-    val status: String,
-    val statusName: String,
-    val recipientAddressRegisteredAt: String
-)
-
-data class GiftDeliveryConfirmationResponse(
-    val applicationNo: String,
-    val status: String,
-    val statusName: String,
-    val deliveredAt: String
-)
-
-data class GiftReviewResponse(
-    val reviewId: Long,
-    val applicationNo: String,
-    val rating: Int,
-    val keywords: List<String>,
-    val comment: String?,
-    val createdAt: String?
-)
-```
-
-### 관리자 Request DTO
-
-```kotlin
-data class AdminGiftCategoryRequest(
-    val classificationNumber: String,
-    val categoryCode: String,
-    val name: String,
-    val receiptCode: String,
-    val representativeItem: String,
-    val requiresDamageWaiver: Boolean,
-    val isActive: Boolean
-)
-
-data class AdminGiftSizePriceRequest(
-    val basePriceCan: Int,
-    val salePriceCan: Int,
-    val isActive: Boolean
-)
-
-data class AdminGiftMarkUndeliverableRequest(
-    val reason: String
-)
-```
-
-### 관리자 Response DTO
-
-```kotlin
-data class AdminGiftCategoryResponse(
-    val categoryId: Long,
-    val classificationNumber: String,
-    val categoryCode: String,
-    val name: String,
-    val receiptCode: String,
-    val representativeItem: String,
-    val requiresDamageWaiver: Boolean,
-    val isActive: Boolean
-)
-
-data class AdminGiftListResponse(
-    val totalCount: Long,
-    val items: List<AdminGiftListItemResponse>,
-    val page: Int,
-    val size: Int,
-    val hasNext: Boolean
-)
-
-data class AdminGiftListItemResponse(
-    val applicationNo: String,
-    val senderNickname: String,
-    val recipientNickname: String,
-    val sizeCode: String,
-    val sizeName: String,
-    val categoryName: String,
-    val classificationNumber: String,
-    val courierCompanyName: String?,
-    val trackingNumber: String?,
-    val status: String,
-    val statusName: String,
-    val availableActions: List<String>
-)
-
-data class AdminGiftDetailResponse(
-    val applicationNo: String,
-    val senderInfo: AdminGiftMemberInfoResponse,
-    val recipientInfo: AdminGiftMemberInfoResponse,
-    val productInfo: AdminGiftProductInfoResponse,
-    val inboundDeliveryInfo: AdminGiftInboundDeliveryInfoResponse,
-    val status: String,
-    val statusName: String,
-    val availableActions: List<String>
-)
-
-data class AdminGiftMemberInfoResponse(
-    val nickname: String,
-    val name: String,
-    val phoneNumber: String,
-    val address: String
-)
-
-data class AdminGiftProductInfoResponse(
-    val sizeCode: String,
-    val sizeName: String,
-    val categoryName: String,
-    val classificationNumber: String
-)
-
-data class AdminGiftInboundDeliveryInfoResponse(
-    val courierCompanyName: String?,
-    val trackingNumber: String?
-)
-
-data class AdminGiftSizePriceResponse(
-    val sizeCode: String,
-    val name: String,
-    val basePriceCan: Int,
-    val salePriceCan: Int,
-    val isActive: Boolean
-)
-
-data class AdminGiftOperationStatusResponse(
-    val applicationNo: String,
-    val status: GiftStatus,
-    val statusName: String,
-    val occurredAt: String
-)
-```
-
-## 클라이언트 구현 참고
-
- 선물 푸시 딥링크는 `deepLinkValue=GIFT_DETAIL`, `deepLinkId=applicationNo`를 사용한다.
- 딥링크 진입 후에는 `GET /api/v2/gifts/{applicationNo}`로 상세를 조회해 `direction`, `trackingRequired`, `recipientAddressRequired`를 기준으로 화면과 CTA를 결정한다.
- 운송장 미등록 자동취소는 서버 스케줄러가 처리하며, 팬 클라이언트는 상세 조회의 `status=CANCELED`와 푸시를 기준으로 표시한다.
- 모든 응답은 기존 `ApiResponse.ok(...)` envelope 안의 `data`로 내려간다.
@@ -1,118 +0,0 @@
-CREATE TABLE gift_category (
-    id BIGINT NOT NULL AUTO_INCREMENT COMMENT '내부 기본키',
-    classification_number VARCHAR(3) NOT NULL COMMENT '신청번호에 사용하는 3자리 분류번호',
-    category_code VARCHAR(50) NOT NULL COMMENT '내부 범용코드',
-    name VARCHAR(50) NOT NULL COMMENT '분류명',
-    receipt_code VARCHAR(9) NOT NULL COMMENT '신청번호에 사용하는 접수코드',
-    representative_item VARCHAR(100) NOT NULL COMMENT '대표품목',
-    requires_damage_waiver TINYINT(1) NOT NULL COMMENT '파손면책 동의 필요 여부',
-    is_active TINYINT(1) NOT NULL COMMENT '활성 여부',
-    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '생성 시각',
-    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '수정 시각',
-    PRIMARY KEY (id),
-    UNIQUE KEY uk_gift_category_classification_number (classification_number),
-    UNIQUE KEY uk_gift_category_code (category_code),
-    UNIQUE KEY uk_gift_category_receipt_code (receipt_code)
-) COMMENT='선물 카테고리';
-
-CREATE TABLE gift (
-    id BIGINT NOT NULL AUTO_INCREMENT COMMENT '내부 기본키',
-    application_no VARCHAR(40) NOT NULL COMMENT '신청번호',
-    sender_member_id BIGINT NOT NULL COMMENT '보내는 팬 회원번호',
-    recipient_member_id BIGINT NOT NULL COMMENT '받는 크리에이터 회원번호',
-    status VARCHAR(30) NOT NULL COMMENT '선물 상태',
-    size_code VARCHAR(20) NOT NULL COMMENT '선물 사이즈 코드',
-    category_id BIGINT NOT NULL COMMENT '신청 시 카테고리 ID',
-    category_name_snapshot VARCHAR(50) NOT NULL COMMENT '신청 시 카테고리명 스냅샷',
-    sale_price_can INT NOT NULL COMMENT '신청 시 결제 금액 스냅샷',
-    can_usage_id BIGINT NOT NULL COMMENT '캔 사용내역 ID',
-    sender_terms_agreed TINYINT(1) NOT NULL COMMENT '팬 이용약관 동의 여부',
-    sender_privacy_agreed TINYINT(1) NOT NULL COMMENT '팬 개인정보 동의 여부',
-    sender_terms_agreed_at TIMESTAMP NOT NULL COMMENT '팬 이용약관 동의 시각',
-    sender_privacy_agreed_at TIMESTAMP NOT NULL COMMENT '팬 개인정보 동의 시각',
-    recipient_terms_agreed TINYINT(1) NOT NULL COMMENT '크리에이터 이용약관 동의 여부',
-    recipient_privacy_agreed TINYINT(1) NOT NULL COMMENT '크리에이터 개인정보 동의 여부',
-    recipient_terms_agreed_at TIMESTAMP NULL COMMENT '크리에이터 이용약관 동의 시각',
-    recipient_privacy_agreed_at TIMESTAMP NULL COMMENT '크리에이터 개인정보 동의 시각',
-    damage_waiver_agreed TINYINT(1) NOT NULL COMMENT '파손면책 동의 여부',
-    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '생성 시각',
-    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '수정 시각',
-    PRIMARY KEY (id),
-    UNIQUE KEY uk_gift_application_no (application_no),
-    CONSTRAINT fk_gift_sender_member FOREIGN KEY (sender_member_id) REFERENCES member (id),
-    CONSTRAINT fk_gift_recipient_member FOREIGN KEY (recipient_member_id) REFERENCES member (id),
-    CONSTRAINT fk_gift_category FOREIGN KEY (category_id) REFERENCES gift_category (id),
-    CONSTRAINT fk_gift_can_usage FOREIGN KEY (can_usage_id) REFERENCES use_can (id)
-) COMMENT='선물 신청';
-
-CREATE TABLE gift_delivery (
-    id BIGINT NOT NULL AUTO_INCREMENT COMMENT '내부 기본키',
-    gift_id BIGINT NOT NULL COMMENT '선물 ID',
-    sender_name VARCHAR(50) NOT NULL COMMENT '발신자 이름',
-    sender_phone_number VARCHAR(30) NOT NULL COMMENT '발신자 휴대폰 번호',
-    sender_zip_code VARCHAR(20) NOT NULL COMMENT '발신자 우편번호',
-    sender_address VARCHAR(255) NOT NULL COMMENT '발신자 주소',
-    sender_address_detail VARCHAR(255) NULL COMMENT '발신자 상세주소',
-    recipient_name VARCHAR(50) NULL COMMENT '수신자 이름',
-    recipient_phone_number VARCHAR(30) NULL COMMENT '수신자 휴대폰 번호',
-    recipient_zip_code VARCHAR(20) NULL COMMENT '수신자 우편번호',
-    recipient_address VARCHAR(255) NULL COMMENT '수신자 주소',
-    recipient_address_detail VARCHAR(255) NULL COMMENT '수신자 상세주소',
-    courier_company_name VARCHAR(50) NULL COMMENT '택배사 한글 표시명',
-    tracking_number VARCHAR(100) NULL COMMENT '운송장 번호',
-    tracking_deadline_at TIMESTAMP NOT NULL COMMENT '운송장 등록 기한',
-    recipient_address_deadline_at TIMESTAMP NULL COMMENT '수신자 배송지 입력 기한',
-    tracking_deadline_reminder_sent_at TIMESTAMP NULL COMMENT '운송장 등록 기한 안내 발송 시각',
-    recipient_address_deadline_reminder_sent_at TIMESTAMP NULL COMMENT '수신자 배송지 입력 기한 안내 발송 시각',
-    tracking_registered_at TIMESTAMP NULL COMMENT '운송장 등록 시각',
-    arrived_at_mailbox_at TIMESTAMP NULL COMMENT '사서함 도착 시각',
-    inspection_completed_at TIMESTAMP NULL COMMENT '검수완료 시각',
-    delivered_at TIMESTAMP NULL COMMENT '전달완료 시각',
-    canceled_at TIMESTAMP NULL COMMENT '취소 시각',
-    undeliverable_at TIMESTAMP NULL COMMENT '전달불가 시각',
-    undeliverable_reason VARCHAR(255) NULL COMMENT '전달불가 사유',
-    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '생성 시각',
-    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '수정 시각',
-    PRIMARY KEY (id),
-    UNIQUE KEY uk_gift_delivery_gift_id (gift_id),
-    CONSTRAINT fk_gift_delivery_gift FOREIGN KEY (gift_id) REFERENCES gift (id)
-) COMMENT='선물 배송 정보';
-
-CREATE TABLE gift_size_price (
-    id BIGINT NOT NULL AUTO_INCREMENT COMMENT '내부 기본키',
-    size_code VARCHAR(20) NOT NULL COMMENT '선물 사이즈 코드',
-    base_price_can INT NOT NULL COMMENT '기본 금액',
-    sale_price_can INT NOT NULL COMMENT '결제 금액',
-    is_active TINYINT(1) NOT NULL COMMENT '활성 여부',
-    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '생성 시각',
-    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '수정 시각',
-    PRIMARY KEY (id),
-    UNIQUE KEY uk_gift_size_price_size_code (size_code)
-) COMMENT='선물 사이즈별 가격';
-
-CREATE TABLE gift_review (
-    id BIGINT NOT NULL AUTO_INCREMENT COMMENT '내부 기본키',
-    gift_id BIGINT NOT NULL COMMENT '선물 ID',
-    sender_member_id BIGINT NOT NULL COMMENT '리뷰 작성 팬 회원번호',
-    rating INT NOT NULL COMMENT '별점',
-    keywords TEXT NULL COMMENT '리뷰 키워드 목록',
-    comment VARCHAR(255) NULL COMMENT '추가의견',
-    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '생성 시각',
-    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '수정 시각',
-    PRIMARY KEY (id),
-    UNIQUE KEY uk_gift_review_gift_id (gift_id),
-    CONSTRAINT fk_gift_review_gift FOREIGN KEY (gift_id) REFERENCES gift (id),
-    CONSTRAINT fk_gift_review_sender_member FOREIGN KEY (sender_member_id) REFERENCES member (id)
-) COMMENT='선물 리뷰';
-
-CREATE TABLE gift_application_no_sequence (
-    id BIGINT NOT NULL AUTO_INCREMENT COMMENT '내부 기본키',
-    category_id BIGINT NOT NULL COMMENT '채번 기준 카테고리 ID',
-    sequence_date VARCHAR(6) NOT NULL COMMENT '채번 기준일 yyMMdd',
-    last_sequence INT NOT NULL COMMENT '마지막 일련번호',
-    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '생성 시각',
-    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '수정 시각',
-    PRIMARY KEY (id),
-    UNIQUE KEY uk_gift_application_no_sequence_category_date (category_id, sequence_date),
-    CONSTRAINT fk_gift_application_no_sequence_category FOREIGN KEY (category_id) REFERENCES gift_category (id)
-) COMMENT='선물 신청번호 날짜별 채번';
@@ -120,7 +120,6 @@ class CanService(

                    CanUsage.CHAT_QUOTA_PURCHASE -> "캐릭터 톡 이용권 구매"
                    CanUsage.CHAT_ROOM_RESET -> "캐릭터 톡 초기화"
-                    CanUsage.GIFT -> "선물하기"
                }

                val createdAt = it.createdAt
@@ -54,7 +54,7 @@ class CanPaymentService(
        communityPost: CreatorCommunity? = null,
        auditionApplicant: AuditionApplicant? = null,
        container: String
-    ): UseCan {
+    ) {
        val member = memberRepository.findByIdOrNull(id = memberId)
            ?: throw SodaException(messageKey = "can.payment.invalid_request_retry")
        val useRewardCan = spendRewardCan(member, needCan, container)
@@ -131,8 +131,6 @@ class CanPaymentService(
            useCan.member = member
            useCan.chatRoomId = chatRoomId
            useCan.characterId = characterId
-        } else if (canUsage == CanUsage.GIFT) {
-            useCan.member = member
        } else {
            throw SodaException(messageKey = "common.error.invalid_request")
        }
@@ -162,18 +160,6 @@ class CanPaymentService(
            useCan,
            paymentGateway = PaymentGateway.APPLE_IAP
        )
-
-        return useCan
-    }
-
-    @Transactional
-    fun spendGiftCan(memberId: Long, needCan: Int, container: String): Long {
-        return spendCan(
-            memberId = memberId,
-            needCan = needCan,
-            canUsage = CanUsage.GIFT,
-            container = container
-        ).id!!
    }

    private fun setUseCanCalculate(
@@ -338,24 +324,6 @@ class CanPaymentService(
            roomId = roomId,
            canUsage = CanUsage.LIVE
        ) ?: throw SodaException(messageKey = "can.payment.invalid_reservation")
-        refundUseCan(member, useCan)
-    }
-
-    @Transactional
-    fun refundGiftCan(memberId: Long, useCanId: Long) {
-        val member = memberRepository.findByIdOrNull(memberId)
-            ?: throw SodaException(messageKey = "common.error.invalid_request")
-        val useCan = useCanRepository.findByIdOrNull(useCanId)
-            ?: throw SodaException(messageKey = "common.error.invalid_request")
-
-        if (useCan.member?.id != member.id || useCan.canUsage != CanUsage.GIFT || useCan.isRefund) {
-            throw SodaException(messageKey = "common.error.invalid_request")
-        }
-
-        refundUseCan(member, useCan)
-    }
-
-    private fun refundUseCan(member: Member, useCan: UseCan) {
        useCan.isRefund = true

        val useCanCalculates = useCanCalculateRepository.findByUseCanIdAndStatus(useCan.id!!)
@@ -14,6 +14,5 @@ enum class CanUsage {
    CHAT_MESSAGE_PURCHASE, // 메시지를 통한 구매(이미지 등 다양한 리소스에 공통 적용)
    CHARACTER_IMAGE_PURCHASE, // 캐릭터 이미지 단독 구매
    CHAT_QUOTA_PURCHASE, // 채팅 횟수(쿼터) 충전
-    CHAT_ROOM_RESET, // 채팅방 초기화 결제(별도 구분)
-    GIFT
+    CHAT_ROOM_RESET // 채팅방 초기화 결제(별도 구분)
 }
@@ -25,8 +25,7 @@ enum class FcmDeepLinkValue(val value: String) {
    SERIES("series"),
    AUDITION("audition"),
    COMMUNITY("community"),
-    CHAT("chat"),
-    GIFT_DETAIL("gift-detail")
+    CHAT("chat")
 }

 class FcmEvent(
@@ -51,7 +50,7 @@ class FcmEvent(
    val creatorId: Long? = null,
    val auditionId: Long? = null,
    val deepLinkValue: FcmDeepLinkValue? = null,
-    val deepLinkId: Any? = null,
+    val deepLinkId: Long? = null,
    val deepLinkCommentPostId: Long? = null,
    val commentParentId: Long? = null,
    val myMemberId: Long? = null,
@@ -32,7 +32,7 @@ class FcmService(
        creatorId: Long? = null,
        auditionId: Long? = null,
        deepLinkValue: FcmDeepLinkValue? = null,
-        deepLinkId: Any? = null,
+        deepLinkId: Long? = null,
        deepLinkCommentPostId: Long? = null,
        chatType: String? = null
    ) {
@@ -118,7 +118,7 @@ class FcmService(

    private fun createDeepLink(
        deepLinkValue: FcmDeepLinkValue?,
-        deepLinkId: Any?,
+        deepLinkId: Long?,
        deepLinkCommentPostId: Long?
    ): String? {
        return buildDeepLink(serverEnv, deepLinkValue, deepLinkId, deepLinkCommentPostId)
@@ -194,7 +194,7 @@ class FcmService(
        fun buildDeepLink(
            serverEnv: String,
            deepLinkValue: FcmDeepLinkValue?,
-            deepLinkId: Any?,
+            deepLinkId: Long?,
            deepLinkCommentPostId: Long? = null
        ): String? {
            if (deepLinkValue == null || deepLinkId == null) {
@@ -222,7 +222,7 @@ class FcmService(
            creatorId: Long? = null,
            auditionId: Long? = null,
            deepLinkValue: FcmDeepLinkValue? = null,
-            deepLinkId: Any? = null,
+            deepLinkId: Long? = null,
            deepLinkCommentPostId: Long? = null,
            deepLink: String? = null,
            chatType: String? = null
@@ -6,7 +6,6 @@ enum class PushNotificationCategory(val code: String) {
    COMMUNITY("community"),
    MESSAGE("message"),
    AUDITION("audition"),
-    GIFT("gift"),
    SYSTEM("system");

    companion object {
@@ -1,7 +1,6 @@
 package kr.co.vividnext.sodalive.menu

 import kr.co.vividnext.sodalive.member.Member
-import kr.co.vividnext.sodalive.member.MemberRole
 import org.springframework.stereotype.Service

@Service
@@ -9,20 +8,6 @@ class MenuService(
    private val repository: MenuRepository
 ) {
    fun getMenus(member: Member): List<GetMenuResponse> {
-        val menus = repository.getMenu(member.role)
-        if (member.role != MemberRole.ADMIN) return menus
-
-        return menus + giftManagementMenu
-    }
-
-    private companion object {
-        val giftManagementMenu = GetMenuResponse(
-            title = "선물함 관리",
-            items = listOf(
-                GetMenuResponse(title = "선물함 리스트", route = "/gift/list"),
-                GetMenuResponse(title = "선물 카테고리", route = "/gift/category"),
-                GetMenuResponse(title = "선물 사이즈", route = "/gift/size")
-            )
-        )
+        return repository.getMenu(member.role)
    }
 }
@@ -1,96 +0,0 @@
-package kr.co.vividnext.sodalive.v2.api.admin.gift.adapter.`in`.web
-
-import kr.co.vividnext.sodalive.common.ApiResponse
-import kr.co.vividnext.sodalive.v2.api.admin.gift.dto.AdminGiftCategoryRequest
-import kr.co.vividnext.sodalive.v2.api.admin.gift.dto.AdminGiftCategoryResponse
-import kr.co.vividnext.sodalive.v2.api.admin.gift.dto.AdminGiftDetailResponse
-import kr.co.vividnext.sodalive.v2.api.admin.gift.dto.AdminGiftListResponse
-import kr.co.vividnext.sodalive.v2.api.admin.gift.dto.AdminGiftMarkUndeliverableRequest
-import kr.co.vividnext.sodalive.v2.api.admin.gift.dto.AdminGiftOperationStatusResponse
-import kr.co.vividnext.sodalive.v2.api.admin.gift.dto.AdminGiftSizePriceRequest
-import kr.co.vividnext.sodalive.v2.api.admin.gift.dto.AdminGiftSizePriceResponse
-import kr.co.vividnext.sodalive.v2.gift.application.GiftAdminQueryService
-import kr.co.vividnext.sodalive.v2.gift.application.GiftAdminService
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftSize
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus
-import org.springframework.security.access.prepost.PreAuthorize
-import org.springframework.web.bind.annotation.DeleteMapping
-import org.springframework.web.bind.annotation.GetMapping
-import org.springframework.web.bind.annotation.PathVariable
-import org.springframework.web.bind.annotation.PostMapping
-import org.springframework.web.bind.annotation.PutMapping
-import org.springframework.web.bind.annotation.RequestBody
-import org.springframework.web.bind.annotation.RequestMapping
-import org.springframework.web.bind.annotation.RequestParam
-import org.springframework.web.bind.annotation.RestController
-
-@RestController
-@RequestMapping("/api/v2/admin")
-@PreAuthorize("hasRole('ADMIN')")
-class AdminGiftController(
-    private val service: GiftAdminService,
-    private val queryService: GiftAdminQueryService
-) {
-    @GetMapping("/gifts")
-    fun getGifts(
-        @RequestParam(required = false) status: GiftStatus?,
-        @RequestParam(required = false) applicationNo: String?,
-        @RequestParam(required = false) nickname: String?,
-        @RequestParam(defaultValue = "0") page: Int,
-        @RequestParam(defaultValue = "20") size: Int
-    ) = ApiResponse.ok(AdminGiftListResponse.from(queryService.getGifts(status, applicationNo, nickname, page, size)))
-
-    @GetMapping("/gifts/{applicationNo}")
-    fun getGiftDetail(@PathVariable applicationNo: String) = ApiResponse.ok(
-        AdminGiftDetailResponse.from(queryService.getGiftDetail(applicationNo))
-    )
-
-    @GetMapping("/gift-categories")
-    fun getCategories() = ApiResponse.ok(service.getCategories().map { AdminGiftCategoryResponse.from(it) })
-
-    @PostMapping("/gift-categories")
-    fun createCategory(@RequestBody request: AdminGiftCategoryRequest) = ApiResponse.ok(
-        AdminGiftCategoryResponse.from(service.createCategory(request.toCommand()))
-    )
-
-    @PutMapping("/gift-categories/{categoryId}")
-    fun updateCategory(
-        @PathVariable categoryId: Long,
-        @RequestBody request: AdminGiftCategoryRequest
-    ) = ApiResponse.ok(AdminGiftCategoryResponse.from(service.updateCategory(categoryId, request.toCommand())))
-
-    @DeleteMapping("/gift-categories/{categoryId}")
-    fun deleteCategory(@PathVariable categoryId: Long) = ApiResponse.ok(
-        AdminGiftCategoryResponse.from(service.deleteCategory(categoryId))
-    )
-
-    @GetMapping("/gift-size-prices")
-    fun getSizePrices() = ApiResponse.ok(service.getSizePrices().map { AdminGiftSizePriceResponse.from(it) })
-
-    @PutMapping("/gift-size-prices/{sizeCode}")
-    fun updateSizePrice(
-        @PathVariable sizeCode: GiftSize,
-        @RequestBody request: AdminGiftSizePriceRequest
-    ) = ApiResponse.ok(AdminGiftSizePriceResponse.from(service.updateSizePrice(sizeCode, request.toCommand())))
-
-    @PostMapping("/gifts/{applicationNo}/arrive-mailbox")
-    fun arriveMailbox(@PathVariable applicationNo: String) = ApiResponse.ok(
-        AdminGiftOperationStatusResponse.from(service.arriveMailbox(applicationNo))
-    )
-
-    @PostMapping("/gifts/{applicationNo}/complete-inspection")
-    fun completeInspection(@PathVariable applicationNo: String) = ApiResponse.ok(
-        AdminGiftOperationStatusResponse.from(service.completeInspection(applicationNo))
-    )
-
-    @PostMapping("/gifts/{applicationNo}/mark-undeliverable")
-    fun markUndeliverable(
-        @PathVariable applicationNo: String,
-        @RequestBody request: AdminGiftMarkUndeliverableRequest
-    ) = ApiResponse.ok(AdminGiftOperationStatusResponse.from(service.markUndeliverable(applicationNo, request.reason)))
-
-    @PostMapping("/gifts/{applicationNo}/complete-delivery")
-    fun completeDelivery(@PathVariable applicationNo: String) = ApiResponse.ok(
-        AdminGiftOperationStatusResponse.from(service.completeDelivery(applicationNo))
-    )
-}
@@ -1,40 +0,0 @@
-package kr.co.vividnext.sodalive.v2.api.admin.gift.dto
-
-import kr.co.vividnext.sodalive.v2.gift.application.GiftCategoryCommand
-import kr.co.vividnext.sodalive.v2.gift.application.GiftSizePriceCommand
-
-data class AdminGiftCategoryRequest(
-    val classificationNumber: String,
-    val categoryCode: String,
-    val name: String,
-    val receiptCode: String,
-    val representativeItem: String,
-    val requiresDamageWaiver: Boolean,
-    val isActive: Boolean
-) {
-    fun toCommand() = GiftCategoryCommand(
-        classificationNumber = classificationNumber,
-        categoryCode = categoryCode,
-        name = name,
-        receiptCode = receiptCode,
-        representativeItem = representativeItem,
-        requiresDamageWaiver = requiresDamageWaiver,
-        isActive = isActive
-    )
-}
-
-data class AdminGiftSizePriceRequest(
-    val basePriceCan: Int,
-    val salePriceCan: Int,
-    val isActive: Boolean
-) {
-    fun toCommand() = GiftSizePriceCommand(
-        basePriceCan = basePriceCan,
-        salePriceCan = salePriceCan,
-        isActive = isActive
-    )
-}
-
-data class AdminGiftMarkUndeliverableRequest(
-    val reason: String
-)
@@ -1,189 +0,0 @@
-package kr.co.vividnext.sodalive.v2.api.admin.gift.dto
-
-import kr.co.vividnext.sodalive.extensions.toUtcIso
-import kr.co.vividnext.sodalive.v2.gift.application.AdminGiftDetailResult
-import kr.co.vividnext.sodalive.v2.gift.application.AdminGiftInboundDeliveryInfoResult
-import kr.co.vividnext.sodalive.v2.gift.application.AdminGiftListItemResult
-import kr.co.vividnext.sodalive.v2.gift.application.AdminGiftListResult
-import kr.co.vividnext.sodalive.v2.gift.application.AdminGiftMemberInfoResult
-import kr.co.vividnext.sodalive.v2.gift.application.AdminGiftProductInfoResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftCategoryResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftOperationStatusResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftSizePriceResult
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus
-
-data class AdminGiftCategoryResponse(
-    val categoryId: Long,
-    val classificationNumber: String,
-    val categoryCode: String,
-    val name: String,
-    val receiptCode: String,
-    val representativeItem: String,
-    val requiresDamageWaiver: Boolean,
-    val isActive: Boolean
-) {
-    companion object {
-        fun from(result: GiftCategoryResult) = AdminGiftCategoryResponse(
-            categoryId = result.categoryId,
-            classificationNumber = result.classificationNumber,
-            categoryCode = result.categoryCode,
-            name = result.name,
-            receiptCode = result.receiptCode,
-            representativeItem = result.representativeItem,
-            requiresDamageWaiver = result.requiresDamageWaiver,
-            isActive = result.isActive
-        )
-    }
-}
-
-data class AdminGiftSizePriceResponse(
-    val sizeCode: String,
-    val name: String,
-    val basePriceCan: Int,
-    val salePriceCan: Int,
-    val isActive: Boolean
-) {
-    companion object {
-        fun from(result: GiftSizePriceResult) = AdminGiftSizePriceResponse(
-            sizeCode = result.sizeCode.name,
-            name = result.sizeName,
-            basePriceCan = result.basePriceCan,
-            salePriceCan = result.salePriceCan,
-            isActive = result.isActive
-        )
-    }
-}
-
-data class AdminGiftOperationStatusResponse(
-    val applicationNo: String,
-    val status: GiftStatus,
-    val statusName: String,
-    val occurredAt: String
-) {
-    companion object {
-        fun from(result: GiftOperationStatusResult) = AdminGiftOperationStatusResponse(
-            applicationNo = result.applicationNo,
-            status = result.status,
-            statusName = result.statusName,
-            occurredAt = result.occurredAt.toUtcIso()
-        )
-    }
-}
-
-data class AdminGiftListResponse(
-    val totalCount: Long,
-    val items: List<AdminGiftListItemResponse>,
-    val page: Int,
-    val size: Int,
-    val hasNext: Boolean
-) {
-    companion object {
-        fun from(result: AdminGiftListResult) = AdminGiftListResponse(
-            totalCount = result.totalCount,
-            items = result.items.map { AdminGiftListItemResponse.from(it) },
-            page = result.page,
-            size = result.size,
-            hasNext = result.hasNext
-        )
-    }
-}
-
-data class AdminGiftListItemResponse(
-    val applicationNo: String,
-    val senderNickname: String,
-    val recipientNickname: String,
-    val sizeCode: String,
-    val sizeName: String,
-    val categoryName: String,
-    val classificationNumber: String,
-    val courierCompanyName: String?,
-    val trackingNumber: String?,
-    val status: GiftStatus,
-    val statusName: String,
-    val availableActions: List<String>
-) {
-    companion object {
-        fun from(result: AdminGiftListItemResult) = AdminGiftListItemResponse(
-            applicationNo = result.applicationNo,
-            senderNickname = result.senderNickname,
-            recipientNickname = result.recipientNickname,
-            sizeCode = result.sizeCode,
-            sizeName = result.sizeName,
-            categoryName = result.categoryName,
-            classificationNumber = result.classificationNumber,
-            courierCompanyName = result.courierCompanyName,
-            trackingNumber = result.trackingNumber,
-            status = result.status,
-            statusName = result.statusName,
-            availableActions = result.availableActions
-        )
-    }
-}
-
-data class AdminGiftDetailResponse(
-    val applicationNo: String,
-    val senderInfo: AdminGiftMemberInfoResponse,
-    val recipientInfo: AdminGiftMemberInfoResponse,
-    val productInfo: AdminGiftProductInfoResponse,
-    val inboundDeliveryInfo: AdminGiftInboundDeliveryInfoResponse,
-    val status: GiftStatus,
-    val statusName: String,
-    val availableActions: List<String>
-) {
-    companion object {
-        fun from(result: AdminGiftDetailResult) = AdminGiftDetailResponse(
-            applicationNo = result.applicationNo,
-            senderInfo = AdminGiftMemberInfoResponse.from(result.senderInfo),
-            recipientInfo = AdminGiftMemberInfoResponse.from(result.recipientInfo),
-            productInfo = AdminGiftProductInfoResponse.from(result.productInfo),
-            inboundDeliveryInfo = AdminGiftInboundDeliveryInfoResponse.from(result.inboundDeliveryInfo),
-            status = result.status,
-            statusName = result.statusName,
-            availableActions = result.availableActions
-        )
-    }
-}
-
-data class AdminGiftMemberInfoResponse(
-    val nickname: String,
-    val name: String,
-    val phoneNumber: String,
-    val address: String
-) {
-    companion object {
-        fun from(result: AdminGiftMemberInfoResult) = AdminGiftMemberInfoResponse(
-            nickname = result.nickname,
-            name = result.name,
-            phoneNumber = result.phoneNumber,
-            address = result.address
-        )
-    }
-}
-
-data class AdminGiftProductInfoResponse(
-    val sizeCode: String,
-    val sizeName: String,
-    val categoryName: String,
-    val classificationNumber: String
-) {
-    companion object {
-        fun from(result: AdminGiftProductInfoResult) = AdminGiftProductInfoResponse(
-            sizeCode = result.sizeCode,
-            sizeName = result.sizeName,
-            categoryName = result.categoryName,
-            classificationNumber = result.classificationNumber
-        )
-    }
-}
-
-data class AdminGiftInboundDeliveryInfoResponse(
-    val courierCompanyName: String?,
-    val trackingNumber: String?
-) {
-    companion object {
-        fun from(result: AdminGiftInboundDeliveryInfoResult) = AdminGiftInboundDeliveryInfoResponse(
-            courierCompanyName = result.courierCompanyName,
-            trackingNumber = result.trackingNumber
-        )
-    }
-}
@@ -1,153 +0,0 @@
-package kr.co.vividnext.sodalive.v2.api.gift.adapter.`in`.web
-
-import kr.co.vividnext.sodalive.common.ApiResponse
-import kr.co.vividnext.sodalive.common.SodaException
-import kr.co.vividnext.sodalive.member.Member
-import kr.co.vividnext.sodalive.v2.api.gift.dto.GiftApplicationRequest
-import kr.co.vividnext.sodalive.v2.api.gift.dto.GiftApplicationResponse
-import kr.co.vividnext.sodalive.v2.api.gift.dto.GiftCancellationResponse
-import kr.co.vividnext.sodalive.v2.api.gift.dto.GiftDeliveryConfirmationResponse
-import kr.co.vividnext.sodalive.v2.api.gift.dto.GiftDetailResponse
-import kr.co.vividnext.sodalive.v2.api.gift.dto.GiftFormOptionsResponse
-import kr.co.vividnext.sodalive.v2.api.gift.dto.GiftListResponse
-import kr.co.vividnext.sodalive.v2.api.gift.dto.GiftRecipientAddressRegistrationRequest
-import kr.co.vividnext.sodalive.v2.api.gift.dto.GiftRecipientAddressRegistrationResponse
-import kr.co.vividnext.sodalive.v2.api.gift.dto.GiftReviewRequest
-import kr.co.vividnext.sodalive.v2.api.gift.dto.GiftReviewResponse
-import kr.co.vividnext.sodalive.v2.api.gift.dto.GiftTrackingRegistrationRequest
-import kr.co.vividnext.sodalive.v2.api.gift.dto.GiftTrackingRegistrationResponse
-import kr.co.vividnext.sodalive.v2.gift.application.GiftCommandService
-import kr.co.vividnext.sodalive.v2.gift.application.GiftQueryService
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftListType
-import org.springframework.security.core.annotation.AuthenticationPrincipal
-import org.springframework.web.bind.annotation.GetMapping
-import org.springframework.web.bind.annotation.PathVariable
-import org.springframework.web.bind.annotation.PostMapping
-import org.springframework.web.bind.annotation.RequestBody
-import org.springframework.web.bind.annotation.RequestMapping
-import org.springframework.web.bind.annotation.RequestParam
-import org.springframework.web.bind.annotation.RestController
-
-@RestController
-@RequestMapping("/api/v2/gifts")
-class GiftController(
-    private val queryService: GiftQueryService,
-    private val commandService: GiftCommandService
-) {
-    @GetMapping("/form-options")
-    fun getFormOptions() = ApiResponse.ok(GiftFormOptionsResponse.from(queryService.getFormOptions()))
-
-    @GetMapping
-    fun getGifts(
-        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
-        @RequestParam(defaultValue = "ALL") type: GiftListType,
-        @RequestParam(defaultValue = "0") page: Int,
-        @RequestParam(defaultValue = "20") size: Int
-    ) = ApiResponse.ok(
-        GiftListResponse.from(
-            queryService.getGifts(
-                memberId = member?.id ?: throw SodaException(messageKey = "common.error.bad_credentials"),
-                type = type,
-                page = page,
-                size = size
-            )
-        )
-    )
-
-    @GetMapping("/{applicationNo}")
-    fun getGiftDetail(
-        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
-        @PathVariable applicationNo: String
-    ) = ApiResponse.ok(
-        GiftDetailResponse.from(
-            queryService.getGiftDetail(
-                memberId = member?.id ?: throw SodaException(messageKey = "common.error.bad_credentials"),
-                applicationNo = applicationNo
-            )
-        )
-    )
-
-    @PostMapping
-    fun registerGift(
-        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
-        @RequestBody request: GiftApplicationRequest
-    ) = ApiResponse.ok(
-        GiftApplicationResponse.from(
-            commandService.registerGift(
-                member = member ?: throw SodaException(messageKey = "common.error.bad_credentials"),
-                command = request.toCommand()
-            )
-        )
-    )
-
-    @PostMapping("/{applicationNo}/cancel")
-    fun cancelGift(
-        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
-        @PathVariable applicationNo: String
-    ) = ApiResponse.ok(
-        GiftCancellationResponse.from(
-            commandService.cancelGift(
-                member = member ?: throw SodaException(messageKey = "common.error.bad_credentials"),
-                applicationNo = applicationNo
-            )
-        )
-    )
-
-    @PostMapping("/{applicationNo}/tracking")
-    fun registerTracking(
-        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
-        @PathVariable applicationNo: String,
-        @RequestBody request: GiftTrackingRegistrationRequest
-    ) = ApiResponse.ok(
-        GiftTrackingRegistrationResponse.from(
-            commandService.registerTracking(
-                member = member ?: throw SodaException(messageKey = "common.error.bad_credentials"),
-                applicationNo = applicationNo,
-                command = request.toCommand()
-            )
-        )
-    )
-
-    @PostMapping("/{applicationNo}/recipient-address")
-    fun registerRecipientAddress(
-        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
-        @PathVariable applicationNo: String,
-        @RequestBody request: GiftRecipientAddressRegistrationRequest
-    ) = ApiResponse.ok(
-        GiftRecipientAddressRegistrationResponse.from(
-            commandService.registerRecipientAddress(
-                member = member ?: throw SodaException(messageKey = "common.error.bad_credentials"),
-                applicationNo = applicationNo,
-                command = request.toCommand()
-            )
-        )
-    )
-
-    @PostMapping("/{applicationNo}/delivery-complete")
-    fun confirmDelivery(
-        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
-        @PathVariable applicationNo: String
-    ) = ApiResponse.ok(
-        GiftDeliveryConfirmationResponse.from(
-            commandService.confirmDelivery(
-                member = member ?: throw SodaException(messageKey = "common.error.bad_credentials"),
-                applicationNo = applicationNo
-            )
-        )
-    )
-
-    @PostMapping("/{applicationNo}/review")
-    fun writeReview(
-        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
-        @PathVariable applicationNo: String,
-        @RequestBody request: GiftReviewRequest
-    ) = ApiResponse.ok(
-        GiftReviewResponse.from(
-            commandService.writeReview(
-                member = member ?: throw SodaException(messageKey = "common.error.bad_credentials"),
-                applicationNo = applicationNo,
-                command = request.toCommand()
-            )
-        )
-    )
-}
@@ -1,32 +0,0 @@
-package kr.co.vividnext.sodalive.v2.api.gift.dto
-
-import kr.co.vividnext.sodalive.v2.gift.application.GiftApplicationCommand
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftSize
-
-data class GiftApplicationRequest(
-    val recipientMemberId: Long,
-    val senderName: String,
-    val senderPhoneNumber: String,
-    val senderZipCode: String,
-    val senderAddress: String,
-    val senderAddressDetail: String?,
-    val sizeCode: GiftSize,
-    val categoryId: Long,
-    val senderTermsAgreed: Boolean,
-    val senderPrivacyAgreed: Boolean,
-    val damageWaiverAgreed: Boolean
-) {
-    fun toCommand() = GiftApplicationCommand(
-        recipientMemberId = recipientMemberId,
-        senderName = senderName,
-        senderPhoneNumber = senderPhoneNumber,
-        senderZipCode = senderZipCode,
-        senderAddress = senderAddress,
-        senderAddressDetail = senderAddressDetail,
-        sizeCode = sizeCode,
-        categoryId = categoryId,
-        senderTermsAgreed = senderTermsAgreed,
-        senderPrivacyAgreed = senderPrivacyAgreed,
-        damageWaiverAgreed = damageWaiverAgreed
-    )
-}
@@ -1,23 +0,0 @@
-package kr.co.vividnext.sodalive.v2.api.gift.dto
-
-import kr.co.vividnext.sodalive.v2.gift.application.GiftRecipientAddressRegistrationCommand
-
-data class GiftRecipientAddressRegistrationRequest(
-    val recipientName: String,
-    val recipientPhoneNumber: String,
-    val recipientZipCode: String,
-    val recipientAddress: String,
-    val recipientAddressDetail: String?,
-    val recipientTermsAgreed: Boolean,
-    val recipientPrivacyAgreed: Boolean
-) {
-    fun toCommand() = GiftRecipientAddressRegistrationCommand(
-        name = recipientName,
-        phoneNumber = recipientPhoneNumber,
-        zipCode = recipientZipCode,
-        address = recipientAddress,
-        addressDetail = recipientAddressDetail,
-        recipientTermsAgreed = recipientTermsAgreed,
-        recipientPrivacyAgreed = recipientPrivacyAgreed
-    )
-}
@@ -1,275 +0,0 @@
-package kr.co.vividnext.sodalive.v2.api.gift.dto
-
-import kr.co.vividnext.sodalive.extensions.toUtcIso
-import kr.co.vividnext.sodalive.v2.gift.application.GiftApplicationResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftCancellationResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftDeliveryConfirmationResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftDetailResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftFormOptionsResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftListResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftRecipientAddressRegistrationResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftReviewResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftTrackingRegistrationResult
-
-data class GiftFormOptionsResponse(
-    val sizes: List<GiftSizeOptionResponse>,
-    val categories: List<GiftCategoryOptionResponse>
-) {
-    companion object {
-        fun from(result: GiftFormOptionsResult) = GiftFormOptionsResponse(
-            sizes = result.sizes.map {
-                GiftSizeOptionResponse(it.sizeCode.name, it.sizeName, it.basePriceCan, it.salePriceCan)
-            },
-            categories = result.categories.map {
-                GiftCategoryOptionResponse(it.categoryId, it.name, it.requiresDamageWaiver)
-            }
-        )
-    }
-}
-
-data class GiftSizeOptionResponse(
-    val sizeCode: String,
-    val name: String,
-    val basePriceCan: Int,
-    val salePriceCan: Int
-)
-
-data class GiftCategoryOptionResponse(
-    val categoryId: Long,
-    val name: String,
-    val requiresDamageWaiver: Boolean
-)
-
-data class GiftListResponse(
-    val totalCount: Long,
-    val items: List<GiftListItemResponse>,
-    val page: Int,
-    val size: Int,
-    val hasNext: Boolean
-) {
-    companion object {
-        fun from(result: GiftListResult) = GiftListResponse(
-            totalCount = result.totalCount,
-            items = result.items.map {
-                GiftListItemResponse(
-                    applicationNo = it.applicationNo,
-                    direction = it.direction.name,
-                    status = it.status.name,
-                    statusName = it.statusName,
-                    priceCan = it.priceCan,
-                    categoryName = it.categoryName,
-                    sizeName = it.sizeName,
-                    createdAt = it.createdAt?.toUtcIso()
-                )
-            },
-            page = result.page,
-            size = result.size,
-            hasNext = result.hasNext
-        )
-    }
-}
-
-data class GiftListItemResponse(
-    val applicationNo: String,
-    val direction: String,
-    val status: String,
-    val statusName: String,
-    val priceCan: Int,
-    val categoryName: String,
-    val sizeName: String,
-    val createdAt: String?
-)
-
-data class GiftDetailResponse(
-    val applicationNo: String,
-    val direction: String,
-    val status: String,
-    val statusName: String,
-    val giftInfo: GiftDetailInfoResponse,
-    val senderInfo: GiftAddressResponse?,
-    val recipientAddress: GiftAddressResponse?,
-    val mailbox: GiftMailboxResponse?,
-    val trackingRequired: Boolean,
-    val recipientAddressRequired: Boolean,
-    val recipientAddressDeadlineAt: String?,
-    val delivery: GiftDeliveryInfoResponse,
-    val statusTimeline: List<GiftStatusTimelineResponse>
-) {
-    companion object {
-        fun from(result: GiftDetailResult) = GiftDetailResponse(
-            applicationNo = result.applicationNo,
-            direction = result.direction.name,
-            status = result.status.name,
-            statusName = result.statusName,
-            giftInfo = GiftDetailInfoResponse(
-                recipientCreatorNickname = result.giftInfo.recipientCreatorNickname,
-                senderNickname = result.giftInfo.senderNickname,
-                sizeName = result.giftInfo.sizeName,
-                categoryName = result.giftInfo.categoryName,
-                applicationNo = result.giftInfo.applicationNo,
-                paidCan = result.giftInfo.paidCan,
-                tracking = result.giftInfo.tracking,
-                shippingRequestedAt = result.giftInfo.shippingRequestedAt?.toUtcIso()
-            ),
-            senderInfo = result.senderInfo?.let { GiftAddressResponse(it.name, it.phoneNumber, it.address) },
-            recipientAddress = result.recipientAddress?.let { GiftAddressResponse(it.name, it.phoneNumber, it.address) },
-            mailbox = result.mailbox?.let { GiftMailboxResponse(it.name, it.address, it.phoneNumber) },
-            trackingRequired = result.trackingRequired,
-            recipientAddressRequired = result.recipientAddressRequired,
-            recipientAddressDeadlineAt = result.recipientAddressDeadlineAt?.toUtcIso(),
-            delivery = GiftDeliveryInfoResponse(
-                canceledAt = result.delivery.canceledAt?.toUtcIso(),
-                undeliverableAt = result.delivery.undeliverableAt?.toUtcIso(),
-                undeliverableReason = result.delivery.undeliverableReason
-            ),
-            statusTimeline = result.statusTimeline.map {
-                GiftStatusTimelineResponse(it.status.name, it.statusName, it.occurredAt?.toUtcIso())
-            }
-        )
-    }
-}
-
-data class GiftDetailInfoResponse(
-    val recipientCreatorNickname: String?,
-    val senderNickname: String?,
-    val sizeName: String,
-    val categoryName: String,
-    val applicationNo: String?,
-    val paidCan: Int?,
-    val tracking: String?,
-    val shippingRequestedAt: String?
-)
-
-data class GiftAddressResponse(
-    val name: String,
-    val phoneNumber: String,
-    val address: String
-)
-
-data class GiftMailboxResponse(
-    val name: String,
-    val address: String,
-    val phoneNumber: String
-)
-
-data class GiftDeliveryInfoResponse(
-    val canceledAt: String?,
-    val undeliverableAt: String?,
-    val undeliverableReason: String?
-)
-
-data class GiftStatusTimelineResponse(
-    val status: String,
-    val statusName: String,
-    val occurredAt: String?
-)
-
-data class GiftApplicationResponse(
-    val applicationNo: String,
-    val status: String,
-    val statusName: String,
-    val priceCan: Int,
-    val trackingDeadlineAt: String
-) {
-    companion object {
-        fun from(result: GiftApplicationResult) = GiftApplicationResponse(
-            applicationNo = result.applicationNo,
-            status = result.status.name,
-            statusName = result.statusName,
-            priceCan = result.priceCan,
-            trackingDeadlineAt = result.trackingDeadlineAt.toUtcIso()
-        )
-    }
-}
-
-data class GiftCancellationResponse(
-    val applicationNo: String,
-    val status: String,
-    val statusName: String,
-    val priceCan: Int,
-    val canceledAt: String
-) {
-    companion object {
-        fun from(result: GiftCancellationResult) = GiftCancellationResponse(
-            applicationNo = result.applicationNo,
-            status = result.status.name,
-            statusName = result.statusName,
-            priceCan = result.priceCan,
-            canceledAt = result.canceledAt.toUtcIso()
-        )
-    }
-}
-
-data class GiftTrackingRegistrationResponse(
-    val applicationNo: String,
-    val status: String,
-    val statusName: String,
-    val courierCompanyName: String,
-    val trackingNumber: String,
-    val trackingRegisteredAt: String,
-    val recipientAddressDeadlineAt: String
-) {
-    companion object {
-        fun from(result: GiftTrackingRegistrationResult) = GiftTrackingRegistrationResponse(
-            applicationNo = result.applicationNo,
-            status = result.status.name,
-            statusName = result.statusName,
-            courierCompanyName = result.courierCompanyName,
-            trackingNumber = result.trackingNumber,
-            trackingRegisteredAt = result.trackingRegisteredAt.toUtcIso(),
-            recipientAddressDeadlineAt = result.recipientAddressDeadlineAt.toUtcIso()
-        )
-    }
-}
-
-data class GiftRecipientAddressRegistrationResponse(
-    val applicationNo: String,
-    val status: String,
-    val statusName: String,
-    val recipientAddressRegisteredAt: String
-) {
-    companion object {
-        fun from(result: GiftRecipientAddressRegistrationResult) = GiftRecipientAddressRegistrationResponse(
-            applicationNo = result.applicationNo,
-            status = result.status.name,
-            statusName = result.statusName,
-            recipientAddressRegisteredAt = result.recipientAddressRegisteredAt.toUtcIso()
-        )
-    }
-}
-
-data class GiftDeliveryConfirmationResponse(
-    val applicationNo: String,
-    val status: String,
-    val statusName: String,
-    val deliveredAt: String
-) {
-    companion object {
-        fun from(result: GiftDeliveryConfirmationResult) = GiftDeliveryConfirmationResponse(
-            applicationNo = result.applicationNo,
-            status = result.status.name,
-            statusName = result.statusName,
-            deliveredAt = result.deliveredAt.toUtcIso()
-        )
-    }
-}
-
-data class GiftReviewResponse(
-    val reviewId: Long,
-    val applicationNo: String,
-    val rating: Int,
-    val keywords: List<String>,
-    val comment: String?,
-    val createdAt: String?
-) {
-    companion object {
-        fun from(result: GiftReviewResult) = GiftReviewResponse(
-            reviewId = result.reviewId,
-            applicationNo = result.applicationNo,
-            rating = result.rating,
-            keywords = result.keywords,
-            comment = result.comment,
-            createdAt = result.createdAt?.toUtcIso()
-        )
-    }
-}
@@ -1,15 +0,0 @@
-package kr.co.vividnext.sodalive.v2.api.gift.dto
-
-import kr.co.vividnext.sodalive.v2.gift.application.GiftReviewCommand
-
-data class GiftReviewRequest(
-    val rating: Int,
-    val keywords: List<String>,
-    val comment: String?
-) {
-    fun toCommand() = GiftReviewCommand(
-        rating = rating,
-        keywords = keywords,
-        comment = comment
-    )
-}
@@ -1,13 +0,0 @@
-package kr.co.vividnext.sodalive.v2.api.gift.dto
-
-import kr.co.vividnext.sodalive.v2.gift.application.GiftTrackingRegistrationCommand
-
-data class GiftTrackingRegistrationRequest(
-    val courierCompanyName: String,
-    val trackingNumber: String
-) {
-    fun toCommand() = GiftTrackingRegistrationCommand(
-        courierCompanyName = courierCompanyName,
-        trackingNumber = trackingNumber
-    )
-}
@@ -1,75 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence
-
-import kr.co.vividnext.sodalive.common.BaseEntity
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftSize
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus
-import java.time.LocalDateTime
-import javax.persistence.Column
-import javax.persistence.Entity
-import javax.persistence.EnumType
-import javax.persistence.Enumerated
-import javax.persistence.Table
-import javax.persistence.UniqueConstraint
-
-@Entity
-@Table(
-    name = "gift",
-    uniqueConstraints = [UniqueConstraint(name = "uk_gift_application_no", columnNames = ["application_no"])]
-)
-class Gift(
-    @Column(name = "application_no", nullable = false, length = 20)
-    val applicationNo: String,
-
-    @Column(name = "sender_member_id", nullable = false)
-    val senderMemberId: Long,
-
-    @Column(name = "recipient_member_id", nullable = false)
-    val recipientMemberId: Long,
-
-    @Enumerated(EnumType.STRING)
-    @Column(name = "status", nullable = false, length = 30)
-    var status: GiftStatus,
-
-    @Enumerated(EnumType.STRING)
-    @Column(name = "size_code", nullable = false, length = 20)
-    val sizeCode: GiftSize,
-
-    @Column(name = "category_id", nullable = false)
-    val categoryId: Long,
-
-    @Column(name = "category_name_snapshot", nullable = false, length = 50)
-    val categoryNameSnapshot: String,
-
-    @Column(name = "sale_price_can", nullable = false)
-    val salePriceCan: Int,
-
-    @Column(name = "can_usage_id", nullable = false)
-    val canUsageId: Long,
-
-    @Column(name = "sender_terms_agreed", nullable = false)
-    val senderTermsAgreed: Boolean,
-
-    @Column(name = "sender_privacy_agreed", nullable = false)
-    val senderPrivacyAgreed: Boolean,
-
-    @Column(name = "sender_terms_agreed_at", nullable = false)
-    val senderTermsAgreedAt: LocalDateTime,
-
-    @Column(name = "sender_privacy_agreed_at", nullable = false)
-    val senderPrivacyAgreedAt: LocalDateTime,
-
-    @Column(name = "recipient_terms_agreed", nullable = false)
-    var recipientTermsAgreed: Boolean = false,
-
-    @Column(name = "recipient_privacy_agreed", nullable = false)
-    var recipientPrivacyAgreed: Boolean = false,
-
-    @Column(name = "recipient_terms_agreed_at")
-    var recipientTermsAgreedAt: LocalDateTime? = null,
-
-    @Column(name = "recipient_privacy_agreed_at")
-    var recipientPrivacyAgreedAt: LocalDateTime? = null,
-
-    @Column(name = "damage_waiver_agreed", nullable = false)
-    val damageWaiverAgreed: Boolean = false
-) : BaseEntity()
@@ -1,28 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence
-
-import kr.co.vividnext.sodalive.common.BaseEntity
-import javax.persistence.Column
-import javax.persistence.Entity
-import javax.persistence.Table
-import javax.persistence.UniqueConstraint
-
-@Entity
-@Table(
-    name = "gift_application_no_sequence",
-    uniqueConstraints = [
-        UniqueConstraint(
-            name = "uk_gift_application_no_sequence_category_date",
-            columnNames = ["category_id", "sequence_date"]
-        )
-    ]
-)
-class GiftApplicationNoSequence(
-    @Column(name = "category_id", nullable = false)
-    val categoryId: Long,
-
-    @Column(name = "sequence_date", nullable = false, length = 6)
-    val sequenceDate: String,
-
-    @Column(name = "last_sequence", nullable = false)
-    var lastSequence: Int
-) : BaseEntity()
@@ -1,25 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence
-
-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 javax.persistence.LockModeType
-
-interface GiftApplicationNoSequenceRepository : JpaRepository<GiftApplicationNoSequence, Long> {
-    fun findByCategoryIdAndSequenceDate(categoryId: Long, sequenceDate: String): GiftApplicationNoSequence?
-
-    @Lock(LockModeType.PESSIMISTIC_WRITE)
-    @Query(
-        """
-        select s
-        from GiftApplicationNoSequence s
-        where s.categoryId = :categoryId
-          and s.sequenceDate = :sequenceDate
-        """
-    )
-    fun findByCategoryIdAndSequenceDateForUpdate(
-        @Param("categoryId") categoryId: Long,
-        @Param("sequenceDate") sequenceDate: String
-    ): GiftApplicationNoSequence?
-}
@@ -1,39 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence
-
-import kr.co.vividnext.sodalive.common.BaseEntity
-import javax.persistence.Column
-import javax.persistence.Entity
-import javax.persistence.Table
-import javax.persistence.UniqueConstraint
-
-@Entity
-@Table(
-    name = "gift_category",
-    uniqueConstraints = [
-        UniqueConstraint(name = "uk_gift_category_classification_number", columnNames = ["classification_number"]),
-        UniqueConstraint(name = "uk_gift_category_code", columnNames = ["category_code"]),
-        UniqueConstraint(name = "uk_gift_category_receipt_code", columnNames = ["receipt_code"])
-    ]
-)
-class GiftCategory(
-    @Column(name = "classification_number", nullable = false, length = 3)
-    var classificationNumber: String,
-
-    @Column(name = "category_code", nullable = false, length = 50)
-    val categoryCode: String,
-
-    @Column(name = "name", nullable = false, length = 50)
-    var name: String,
-
-    @Column(name = "receipt_code", nullable = false, length = 9)
-    var receiptCode: String,
-
-    @Column(name = "representative_item", nullable = false, length = 100)
-    var representativeItem: String,
-
-    @Column(name = "requires_damage_waiver", nullable = false)
-    var requiresDamageWaiver: Boolean = false,
-
-    @Column(name = "is_active", nullable = false)
-    var isActive: Boolean = true
-) : BaseEntity()
@@ -1,7 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence
-
-import org.springframework.data.jpa.repository.JpaRepository
-
-interface GiftCategoryRepository : JpaRepository<GiftCategory, Long> {
-    fun findByCategoryCode(categoryCode: String): GiftCategory?
-}
@@ -1,87 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence
-
-import kr.co.vividnext.sodalive.common.BaseEntity
-import java.time.LocalDateTime
-import javax.persistence.Column
-import javax.persistence.Entity
-import javax.persistence.Table
-import javax.persistence.UniqueConstraint
-
-@Entity
-@Table(
-    name = "gift_delivery",
-    uniqueConstraints = [UniqueConstraint(name = "uk_gift_delivery_gift_id", columnNames = ["gift_id"])]
-)
-class GiftDelivery(
-    @Column(name = "gift_id", nullable = false)
-    val giftId: Long,
-
-    @Column(name = "sender_name", nullable = false, length = 50)
-    val senderName: String,
-
-    @Column(name = "sender_phone_number", nullable = false, length = 30)
-    val senderPhoneNumber: String,
-
-    @Column(name = "sender_zip_code", nullable = false, length = 20)
-    val senderZipCode: String,
-
-    @Column(name = "sender_address", nullable = false, length = 255)
-    val senderAddress: String,
-
-    @Column(name = "sender_address_detail", length = 255)
-    val senderAddressDetail: String? = null,
-
-    @Column(name = "recipient_name", length = 50)
-    var recipientName: String? = null,
-
-    @Column(name = "recipient_phone_number", length = 30)
-    var recipientPhoneNumber: String? = null,
-
-    @Column(name = "recipient_zip_code", length = 20)
-    var recipientZipCode: String? = null,
-
-    @Column(name = "recipient_address", length = 255)
-    var recipientAddress: String? = null,
-
-    @Column(name = "recipient_address_detail", length = 255)
-    var recipientAddressDetail: String? = null,
-
-    @Column(name = "courier_company_name", length = 50)
-    var courierCompanyName: String? = null,
-
-    @Column(name = "tracking_number", length = 100)
-    var trackingNumber: String? = null,
-
-    @Column(name = "tracking_deadline_at", nullable = false)
-    val trackingDeadlineAt: LocalDateTime,
-
-    @Column(name = "recipient_address_deadline_at")
-    var recipientAddressDeadlineAt: LocalDateTime? = null,
-
-    @Column(name = "tracking_deadline_reminder_sent_at")
-    var trackingDeadlineReminderSentAt: LocalDateTime? = null,
-
-    @Column(name = "recipient_address_deadline_reminder_sent_at")
-    var recipientAddressDeadlineReminderSentAt: LocalDateTime? = null,
-
-    @Column(name = "tracking_registered_at")
-    var trackingRegisteredAt: LocalDateTime? = null,
-
-    @Column(name = "arrived_at_mailbox_at")
-    var arrivedAtMailboxAt: LocalDateTime? = null,
-
-    @Column(name = "inspection_completed_at")
-    var inspectionCompletedAt: LocalDateTime? = null,
-
-    @Column(name = "delivered_at")
-    var deliveredAt: LocalDateTime? = null,
-
-    @Column(name = "canceled_at")
-    var canceledAt: LocalDateTime? = null,
-
-    @Column(name = "undeliverable_at")
-    var undeliverableAt: LocalDateTime? = null,
-
-    @Column(name = "undeliverable_reason", length = 255)
-    var undeliverableReason: String? = null
-) : BaseEntity()
@@ -1,9 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence
-
-import org.springframework.data.jpa.repository.JpaRepository
-
-interface GiftDeliveryRepository : JpaRepository<GiftDelivery, Long> {
-    fun findByGiftId(giftId: Long): GiftDelivery?
-
-    fun findByGiftIdIn(giftIds: Collection<Long>): List<GiftDelivery>
-}
@@ -1,141 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence
-
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus
-import org.springframework.data.domain.Page
-import org.springframework.data.domain.Pageable
-import org.springframework.data.jpa.repository.JpaRepository
-import org.springframework.data.jpa.repository.Query
-import org.springframework.data.repository.query.Param
-import java.time.LocalDateTime
-
-interface GiftRepository : JpaRepository<Gift, Long> {
-    fun findByApplicationNo(applicationNo: String): Gift?
-
-    fun findBySenderMemberId(senderMemberId: Long, pageable: Pageable): Page<Gift>
-
-    fun findByRecipientMemberIdAndStatusIn(
-        recipientMemberId: Long,
-        statuses: Collection<GiftStatus>,
-        pageable: Pageable
-    ): Page<Gift>
-
-    fun findBySenderMemberIdOrRecipientMemberIdAndStatusIn(
-        senderMemberId: Long,
-        recipientMemberId: Long,
-        statuses: Collection<GiftStatus>,
-        pageable: Pageable
-    ): Page<Gift>
-
-    @Query(
-        value = """
-        select g
-        from Gift g
-          join Member sender on sender.id = g.senderMemberId
-          join Member recipient on recipient.id = g.recipientMemberId
-        where (:status is null or g.status = :status)
-          and (:applicationNo is null or g.applicationNo like concat('%', :applicationNo, '%'))
-          and (
-            :nickname is null
-            or sender.nickname like concat('%', :nickname, '%')
-            or recipient.nickname like concat('%', :nickname, '%')
-          )
-        """,
-        countQuery = """
-        select count(g)
-        from Gift g
-          join Member sender on sender.id = g.senderMemberId
-          join Member recipient on recipient.id = g.recipientMemberId
-        where (:status is null or g.status = :status)
-          and (:applicationNo is null or g.applicationNo like concat('%', :applicationNo, '%'))
-          and (
-            :nickname is null
-            or sender.nickname like concat('%', :nickname, '%')
-            or recipient.nickname like concat('%', :nickname, '%')
-          )
-        """
-    )
-    fun findAdminGifts(
-        @Param("status") status: GiftStatus?,
-        @Param("applicationNo") applicationNo: String?,
-        @Param("nickname") nickname: String?,
-        pageable: Pageable
-    ): Page<Gift>
-
-    @Query(
-        """
-        select g
-        from Gift g
-        where g.status = kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus.RECEIVED
-          and exists (
-              select d.id
-              from GiftDelivery d
-              where d.giftId = g.id
-                and d.trackingDeadlineAt < :now
-          )
-        """
-    )
-    fun findReceivedGiftsWithTrackingDeadlineBefore(@Param("now") now: LocalDateTime): List<Gift>
-
-    @Query(
-        """
-        select g
-        from Gift g
-        where g.status = kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus.TRACKING_REGISTERED
-          and exists (
-              select d.id
-              from GiftDelivery d
-              where d.giftId = g.id
-                and d.recipientAddressDeadlineAt < :now
-                and d.recipientAddress is null
-          )
-        """
-    )
-    fun findTrackingRegisteredGiftsWithRecipientAddressDeadlineBefore(
-        @Param("now") now: LocalDateTime
-    ): List<Gift>
-
-    @Query(
-        """
-        select g
-        from Gift g
-        where g.status = kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus.RECEIVED
-          and exists (
-              select d.id
-              from GiftDelivery d
-              where d.giftId = g.id
-                and d.trackingDeadlineAt > :now
-                and d.trackingDeadlineAt <= :reminderUntil
-                and d.trackingDeadlineReminderSentAt is null
-          )
-        """
-    )
-    fun findReceivedGiftsWithTrackingDeadlineReminderDue(
-        @Param("now") now: LocalDateTime,
-        @Param("reminderUntil") reminderUntil: LocalDateTime
-    ): List<Gift>
-
-    @Query(
-        """
-        select g
-        from Gift g
-        where g.status in (
-            kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus.TRACKING_REGISTERED,
-            kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus.ARRIVED_AT_MAILBOX,
-            kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus.INSPECTION_COMPLETED
-        )
-          and exists (
-              select d.id
-              from GiftDelivery d
-              where d.giftId = g.id
-                and d.recipientAddressDeadlineAt > :now
-                and d.recipientAddressDeadlineAt <= :reminderUntil
-                and d.recipientAddress is null
-                and d.recipientAddressDeadlineReminderSentAt is null
-          )
-        """
-    )
-    fun findGiftsWithRecipientAddressDeadlineReminderDue(
-        @Param("now") now: LocalDateTime,
-        @Param("reminderUntil") reminderUntil: LocalDateTime
-    ): List<Gift>
-}
@@ -1,29 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence
-
-import kr.co.vividnext.sodalive.common.BaseEntity
-import javax.persistence.Column
-import javax.persistence.Entity
-import javax.persistence.Table
-import javax.persistence.UniqueConstraint
-
-@Entity
-@Table(
-    name = "gift_review",
-    uniqueConstraints = [UniqueConstraint(name = "uk_gift_review_gift_id", columnNames = ["gift_id"])]
-)
-class GiftReview(
-    @Column(name = "gift_id", nullable = false)
-    val giftId: Long,
-
-    @Column(name = "sender_member_id", nullable = false)
-    val senderMemberId: Long,
-
-    @Column(name = "rating", nullable = false)
-    val rating: Int,
-
-    @Column(name = "keywords", columnDefinition = "text")
-    var keywords: String? = null,
-
-    @Column(name = "comment", length = 255)
-    var comment: String? = null
-) : BaseEntity()
@@ -1,7 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence
-
-import org.springframework.data.jpa.repository.JpaRepository
-
-interface GiftReviewRepository : JpaRepository<GiftReview, Long> {
-    fun findByGiftId(giftId: Long): GiftReview?
-}
@@ -1,30 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence
-
-import kr.co.vividnext.sodalive.common.BaseEntity
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftSize
-import javax.persistence.Column
-import javax.persistence.Entity
-import javax.persistence.EnumType
-import javax.persistence.Enumerated
-import javax.persistence.Table
-import javax.persistence.UniqueConstraint
-
-@Entity
-@Table(
-    name = "gift_size_price",
-    uniqueConstraints = [UniqueConstraint(name = "uk_gift_size_price_size_code", columnNames = ["size_code"])]
-)
-class GiftSizePrice(
-    @Enumerated(EnumType.STRING)
-    @Column(name = "size_code", nullable = false, length = 20)
-    val sizeCode: GiftSize,
-
-    @Column(name = "base_price_can", nullable = false)
-    var basePriceCan: Int,
-
-    @Column(name = "sale_price_can", nullable = false)
-    var salePriceCan: Int,
-
-    @Column(name = "is_active", nullable = false)
-    var isActive: Boolean = true
-) : BaseEntity()
@@ -1,8 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence
-
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftSize
-import org.springframework.data.jpa.repository.JpaRepository
-
-interface GiftSizePriceRepository : JpaRepository<GiftSizePrice, Long> {
-    fun findBySizeCode(sizeCode: GiftSize): GiftSizePrice?
-}
@@ -1,101 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.adapter.out.scheduler
-
-import kr.co.vividnext.sodalive.can.payment.CanPaymentService
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDeliveryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftRepository
-import kr.co.vividnext.sodalive.v2.gift.application.GiftPushService
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus
-import org.redisson.api.RedissonClient
-import org.springframework.scheduling.annotation.Scheduled
-import org.springframework.stereotype.Component
-import org.springframework.transaction.annotation.Transactional
-import java.time.LocalDateTime
-import java.util.concurrent.TimeUnit
-
-@Component
-class GiftScheduler(
-    private val giftRepository: GiftRepository,
-    private val giftDeliveryRepository: GiftDeliveryRepository,
-    private val canPaymentService: CanPaymentService,
-    private val giftPushService: GiftPushService,
-    private val redissonClient: RedissonClient
-) {
-    @Scheduled(cron = "0 0 * * * *", zone = "Asia/Seoul")
-    @Transactional
-    fun runExpiredTrackingRegistrationGiftCancellation() {
-        val lock = redissonClient.getLock(EXPIRED_TRACKING_REGISTRATION_GIFTS_LOCK_KEY)
-
-        try {
-            if (lock.tryLock(0, -1, TimeUnit.SECONDS)) {
-                cancelExpiredTrackingRegistrationGifts(LocalDateTime.now())
-            }
-        } finally {
-            if (lock.isHeldByCurrentThread) {
-                lock.unlock()
-            }
-        }
-    }
-
-    @Transactional
-    fun cancelExpiredTrackingRegistrationGifts(now: LocalDateTime): Int {
-        val expiredGifts = giftRepository.findReceivedGiftsWithTrackingDeadlineBefore(now)
-        expiredGifts.forEach { gift ->
-            gift.status = GiftStatus.CANCELED
-            requireNotNull(giftDeliveryRepository.findByGiftId(requireNotNull(gift.id))).canceledAt = now
-            canPaymentService.refundGiftCan(gift.senderMemberId, gift.canUsageId)
-            giftPushService.sendAutoCanceledToSender(gift.applicationNo, gift.senderMemberId)
-        }
-
-        return expiredGifts.size
-    }
-
-    @Transactional
-    fun markExpiredRecipientAddressGiftsUndeliverable(now: LocalDateTime): Int {
-        val expiredGifts = giftRepository.findTrackingRegisteredGiftsWithRecipientAddressDeadlineBefore(now)
-        expiredGifts.forEach { gift ->
-            gift.status = GiftStatus.UNDELIVERABLE
-            val delivery = requireNotNull(giftDeliveryRepository.findByGiftId(requireNotNull(gift.id)))
-            delivery.undeliverableAt = now
-            delivery.undeliverableReason = EXPIRED_RECIPIENT_ADDRESS_REASON
-        }
-
-        return expiredGifts.size
-    }
-
-    @Transactional
-    fun sendDeadlineReminderGifts(now: LocalDateTime): Int {
-        val reminderUntil = now.plusHours(DEADLINE_REMINDER_HOURS)
-        val trackingReminderCount = sendTrackingDeadlineReminders(now, reminderUntil)
-        val recipientAddressReminderCount = sendRecipientAddressDeadlineReminders(now, reminderUntil)
-
-        return trackingReminderCount + recipientAddressReminderCount
-    }
-
-    private fun sendTrackingDeadlineReminders(now: LocalDateTime, reminderUntil: LocalDateTime): Int {
-        val gifts = giftRepository.findReceivedGiftsWithTrackingDeadlineReminderDue(now, reminderUntil)
-        gifts.forEach { gift ->
-            val delivery = requireNotNull(giftDeliveryRepository.findByGiftId(requireNotNull(gift.id)))
-            delivery.trackingDeadlineReminderSentAt = now
-            giftPushService.sendTrackingDeadlineReminder(gift.applicationNo, gift.senderMemberId)
-        }
-
-        return gifts.size
-    }
-
-    private fun sendRecipientAddressDeadlineReminders(now: LocalDateTime, reminderUntil: LocalDateTime): Int {
-        val gifts = giftRepository.findGiftsWithRecipientAddressDeadlineReminderDue(now, reminderUntil)
-        gifts.forEach { gift ->
-            val delivery = requireNotNull(giftDeliveryRepository.findByGiftId(requireNotNull(gift.id)))
-            delivery.recipientAddressDeadlineReminderSentAt = now
-            giftPushService.sendRecipientAddressDeadlineReminder(gift.applicationNo, gift.recipientMemberId)
-        }
-
-        return gifts.size
-    }
-
-    private companion object {
-        const val DEADLINE_REMINDER_HOURS = 24L
-        const val EXPIRED_TRACKING_REGISTRATION_GIFTS_LOCK_KEY = "lock:gift-expired-tracking-registration-cancellation"
-        const val EXPIRED_RECIPIENT_ADDRESS_REASON = "배송지 미입력 기한 초과"
-    }
-}
@@ -1,205 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.application
-
-import kr.co.vividnext.sodalive.common.SodaException
-import kr.co.vividnext.sodalive.member.Member
-import kr.co.vividnext.sodalive.member.MemberRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.Gift
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategory
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategoryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDelivery
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDeliveryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftRepository
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus
-import org.springframework.data.domain.PageRequest
-import org.springframework.data.domain.Sort
-import org.springframework.stereotype.Service
-import org.springframework.transaction.annotation.Transactional
-
-data class AdminGiftListResult(
-    val totalCount: Long,
-    val items: List<AdminGiftListItemResult>,
-    val page: Int,
-    val size: Int,
-    val hasNext: Boolean
-)
-
-data class AdminGiftListItemResult(
-    val applicationNo: String,
-    val senderNickname: String,
-    val recipientNickname: String,
-    val sizeCode: String,
-    val sizeName: String,
-    val categoryName: String,
-    val classificationNumber: String,
-    val courierCompanyName: String?,
-    val trackingNumber: String?,
-    val status: GiftStatus,
-    val statusName: String,
-    val availableActions: List<String>
-)
-
-data class AdminGiftDetailResult(
-    val applicationNo: String,
-    val senderInfo: AdminGiftMemberInfoResult,
-    val recipientInfo: AdminGiftMemberInfoResult,
-    val productInfo: AdminGiftProductInfoResult,
-    val inboundDeliveryInfo: AdminGiftInboundDeliveryInfoResult,
-    val status: GiftStatus,
-    val statusName: String,
-    val availableActions: List<String>
-)
-
-data class AdminGiftMemberInfoResult(
-    val nickname: String,
-    val name: String,
-    val phoneNumber: String,
-    val address: String
-)
-
-data class AdminGiftProductInfoResult(
-    val sizeCode: String,
-    val sizeName: String,
-    val categoryName: String,
-    val classificationNumber: String
-)
-
-data class AdminGiftInboundDeliveryInfoResult(
-    val courierCompanyName: String?,
-    val trackingNumber: String?
-)
-
-@Service
-class GiftAdminQueryService(
-    private val giftRepository: GiftRepository,
-    private val deliveryRepository: GiftDeliveryRepository,
-    private val categoryRepository: GiftCategoryRepository,
-    private val memberRepository: MemberRepository
-) {
-    @Transactional(readOnly = true)
-    fun getGifts(
-        status: GiftStatus?,
-        applicationNo: String?,
-        nickname: String?,
-        page: Int,
-        size: Int
-    ): AdminGiftListResult {
-        val normalizedPage = page.coerceAtLeast(0)
-        val normalizedSize = if (size <= 0) DEFAULT_PAGE_SIZE else size
-        val gifts = giftRepository.findAdminGifts(
-            status = status,
-            applicationNo = applicationNo?.takeIf { it.isNotBlank() },
-            nickname = nickname?.takeIf { it.isNotBlank() },
-            pageable = PageRequest.of(normalizedPage, normalizedSize, Sort.by(Sort.Direction.DESC, "createdAt", "id"))
-        )
-        val context = buildContext(gifts.content)
-
-        return AdminGiftListResult(
-            totalCount = gifts.totalElements,
-            items = gifts.content.map { gift -> gift.toListItem(context) },
-            page = normalizedPage,
-            size = normalizedSize,
-            hasNext = gifts.hasNext()
-        )
-    }
-
-    @Transactional(readOnly = true)
-    fun getGiftDetail(applicationNo: String): AdminGiftDetailResult {
-        val gift = giftRepository.findByApplicationNo(applicationNo) ?: throw invalidRequest()
-        val context = buildContext(listOf(gift))
-        val delivery = context.delivery(gift)
-        val sender = context.sender(gift)
-        val recipient = context.recipient(gift)
-        val category = context.category(gift)
-
-        return AdminGiftDetailResult(
-            applicationNo = gift.applicationNo,
-            senderInfo = AdminGiftMemberInfoResult(
-                nickname = sender.nickname,
-                name = delivery.senderName,
-                phoneNumber = delivery.senderPhoneNumber,
-                address = formatAddress(delivery.senderZipCode, delivery.senderAddress, delivery.senderAddressDetail)
-            ),
-            recipientInfo = AdminGiftMemberInfoResult(
-                nickname = recipient.nickname,
-                name = delivery.recipientName.orEmpty(),
-                phoneNumber = delivery.recipientPhoneNumber.orEmpty(),
-                address = delivery.recipientAddressResult()
-            ),
-            productInfo = AdminGiftProductInfoResult(
-                sizeCode = gift.sizeCode.name,
-                sizeName = gift.sizeCode.displayName,
-                categoryName = gift.categoryNameSnapshot,
-                classificationNumber = category.classificationNumber
-            ),
-            inboundDeliveryInfo = AdminGiftInboundDeliveryInfoResult(
-                courierCompanyName = delivery.courierCompanyName,
-                trackingNumber = delivery.trackingNumber
-            ),
-            status = gift.status,
-            statusName = gift.status.displayName,
-            availableActions = gift.status.availableActions()
-        )
-    }
-
-    private fun Gift.toListItem(context: GiftAdminQueryContext) = AdminGiftListItemResult(
-        applicationNo = applicationNo,
-        senderNickname = context.sender(this).nickname,
-        recipientNickname = context.recipient(this).nickname,
-        sizeCode = sizeCode.name,
-        sizeName = sizeCode.displayName,
-        categoryName = categoryNameSnapshot,
-        classificationNumber = context.category(this).classificationNumber,
-        courierCompanyName = context.delivery(this).courierCompanyName,
-        trackingNumber = context.delivery(this).trackingNumber,
-        status = status,
-        statusName = status.displayName,
-        availableActions = status.availableActions()
-    )
-
-    private fun GiftStatus.availableActions() = when (this) {
-        GiftStatus.TRACKING_REGISTERED -> listOf("ARRIVE_MAILBOX", "MARK_UNDELIVERABLE")
-        GiftStatus.ARRIVED_AT_MAILBOX -> listOf("COMPLETE_INSPECTION", "MARK_UNDELIVERABLE")
-        GiftStatus.INSPECTION_COMPLETED -> listOf("COMPLETE_DELIVERY", "MARK_UNDELIVERABLE")
-        GiftStatus.RECEIVED, GiftStatus.DELIVERED, GiftStatus.UNDELIVERABLE, GiftStatus.CANCELED -> emptyList()
-    }
-
-    private fun GiftDelivery.recipientAddressResult(): String {
-        val zipCode = recipientZipCode ?: return ""
-        val address = recipientAddress ?: return ""
-        return formatAddress(zipCode, address, recipientAddressDetail)
-    }
-
-    private fun formatAddress(zipCode: String, address: String, detail: String?) =
-        "($zipCode) $address" + if (detail.isNullOrBlank()) "" else ", $detail"
-
-    private fun invalidRequest() = SodaException(messageKey = "common.error.invalid_request")
-
-    private fun buildContext(gifts: List<Gift>): GiftAdminQueryContext {
-        val giftIds = gifts.mapNotNull { it.id }
-        val memberIds = gifts.flatMap { listOf(it.senderMemberId, it.recipientMemberId) }.toSet()
-        val categoryIds = gifts.map { it.categoryId }.toSet()
-        return GiftAdminQueryContext(
-            deliveriesByGiftId = deliveryRepository.findByGiftIdIn(giftIds).associateBy { it.giftId },
-            membersById = memberRepository.findAllById(memberIds).associateBy { it.id ?: throw invalidRequest() },
-            categoriesById = categoryRepository.findAllById(categoryIds).associateBy { it.id ?: throw invalidRequest() }
-        )
-    }
-
-    private inner class GiftAdminQueryContext(
-        private val deliveriesByGiftId: Map<Long, GiftDelivery>,
-        private val membersById: Map<Long, Member>,
-        private val categoriesById: Map<Long, GiftCategory>
-    ) {
-        fun delivery(gift: Gift) = deliveriesByGiftId[gift.id] ?: throw invalidRequest()
-
-        fun sender(gift: Gift) = membersById[gift.senderMemberId] ?: throw invalidRequest()
-
-        fun recipient(gift: Gift) = membersById[gift.recipientMemberId] ?: throw invalidRequest()
-
-        fun category(gift: Gift) = categoriesById[gift.categoryId] ?: throw invalidRequest()
-    }
-
-    private companion object {
-        const val DEFAULT_PAGE_SIZE = 20
-    }
-}
@@ -1,231 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.application
-
-import kr.co.vividnext.sodalive.common.SodaException
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategory
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategoryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDeliveryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftSizePrice
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftSizePriceRepository
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftSize
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus
-import org.springframework.data.repository.findByIdOrNull
-import org.springframework.stereotype.Service
-import org.springframework.transaction.annotation.Transactional
-import java.time.LocalDateTime
-
-data class GiftCategoryCommand(
-    val classificationNumber: String,
-    val categoryCode: String,
-    val name: String,
-    val receiptCode: String,
-    val representativeItem: String,
-    val requiresDamageWaiver: Boolean,
-    val isActive: Boolean
-)
-
-data class GiftCategoryResult(
-    val categoryId: Long,
-    val classificationNumber: String,
-    val categoryCode: String,
-    val name: String,
-    val receiptCode: String,
-    val representativeItem: String,
-    val requiresDamageWaiver: Boolean,
-    val isActive: Boolean
-)
-
-data class GiftSizePriceCommand(
-    val basePriceCan: Int,
-    val salePriceCan: Int,
-    val isActive: Boolean
-)
-
-data class GiftSizePriceResult(
-    val sizeCode: GiftSize,
-    val sizeName: String,
-    val basePriceCan: Int,
-    val salePriceCan: Int,
-    val isActive: Boolean
-)
-
-data class GiftOperationStatusResult(
-    val applicationNo: String,
-    val status: GiftStatus,
-    val statusName: String,
-    val occurredAt: LocalDateTime
-)
-
-@Service
-class GiftAdminService(
-    private val categoryRepository: GiftCategoryRepository,
-    private val sizePriceRepository: GiftSizePriceRepository,
-    private val giftRepository: GiftRepository,
-    private val giftDeliveryRepository: GiftDeliveryRepository,
-    private val giftPushService: GiftPushService
-) {
-    @Transactional(readOnly = true)
-    fun getCategories(): List<GiftCategoryResult> = categoryRepository.findAll().map { it.toResult() }
-
-    @Transactional
-    fun createCategory(command: GiftCategoryCommand): GiftCategoryResult {
-        validateCategory(command)
-        return categoryRepository.save(
-            GiftCategory(
-                classificationNumber = command.classificationNumber,
-                categoryCode = command.categoryCode,
-                name = command.name,
-                receiptCode = command.receiptCode,
-                representativeItem = command.representativeItem,
-                requiresDamageWaiver = command.requiresDamageWaiver,
-                isActive = command.isActive
-            )
-        ).toResult()
-    }
-
-    @Transactional
-    fun updateCategory(categoryId: Long, command: GiftCategoryCommand): GiftCategoryResult {
-        validateCategory(command)
-        val category = categoryRepository.findByIdOrNull(categoryId) ?: throw invalidRequest()
-        category.classificationNumber = command.classificationNumber
-        category.name = command.name
-        category.receiptCode = command.receiptCode
-        category.representativeItem = command.representativeItem
-        category.requiresDamageWaiver = command.requiresDamageWaiver
-        category.isActive = command.isActive
-        return category.toResult()
-    }
-
-    @Transactional
-    fun deleteCategory(categoryId: Long): GiftCategoryResult {
-        val category = categoryRepository.findByIdOrNull(categoryId) ?: throw invalidRequest()
-        category.isActive = false
-        return category.toResult()
-    }
-
-    @Transactional(readOnly = true)
-    fun getSizePrices(): List<GiftSizePriceResult> = sizePriceRepository.findAll().map { it.toResult() }
-
-    @Transactional
-    fun updateSizePrice(sizeCode: GiftSize, command: GiftSizePriceCommand): GiftSizePriceResult {
-        validateSizePrice(command)
-        val sizePrice = sizePriceRepository.findBySizeCode(sizeCode)
-            ?: GiftSizePrice(sizeCode = sizeCode, basePriceCan = command.basePriceCan, salePriceCan = command.salePriceCan)
-        sizePrice.basePriceCan = command.basePriceCan
-        sizePrice.salePriceCan = command.salePriceCan
-        sizePrice.isActive = command.isActive
-        return sizePriceRepository.save(sizePrice).toResult()
-    }
-
-    @Transactional
-    fun arriveMailbox(applicationNo: String, now: LocalDateTime = LocalDateTime.now()): GiftOperationStatusResult {
-        val gift = giftRepository.findByApplicationNo(applicationNo) ?: throw invalidRequest()
-        if (gift.status != GiftStatus.TRACKING_REGISTERED) throw invalidRequest()
-        val delivery = giftDeliveryRepository.findByGiftId(requireNotNull(gift.id)) ?: throw invalidRequest()
-
-        gift.status = GiftStatus.ARRIVED_AT_MAILBOX
-        delivery.arrivedAtMailboxAt = now
-        giftPushService.sendArrivedAtMailboxToSender(gift.applicationNo, gift.senderMemberId)
-        giftPushService.sendArrivedAtMailboxToRecipient(gift.applicationNo, gift.recipientMemberId)
-
-        return GiftOperationStatusResult(gift.applicationNo, gift.status, gift.status.displayName, now)
-    }
-
-    @Transactional
-    fun completeInspection(applicationNo: String, now: LocalDateTime = LocalDateTime.now()): GiftOperationStatusResult {
-        val gift = giftRepository.findByApplicationNo(applicationNo) ?: throw invalidRequest()
-        if (gift.status != GiftStatus.ARRIVED_AT_MAILBOX) throw invalidRequest()
-        val delivery = giftDeliveryRepository.findByGiftId(requireNotNull(gift.id)) ?: throw invalidRequest()
-
-        gift.status = GiftStatus.INSPECTION_COMPLETED
-        delivery.inspectionCompletedAt = now
-        giftPushService.sendInspectionCompleted(gift.applicationNo, gift.recipientMemberId)
-
-        return GiftOperationStatusResult(gift.applicationNo, gift.status, gift.status.displayName, now)
-    }
-
-    @Transactional
-    fun markUndeliverable(
-        applicationNo: String,
-        reason: String,
-        now: LocalDateTime = LocalDateTime.now()
-    ): GiftOperationStatusResult {
-        val gift = giftRepository.findByApplicationNo(applicationNo) ?: throw invalidRequest()
-        if (gift.status !in UNDELIVERABLE_ALLOWED_STATUSES || reason.isBlank() || reason.length > 255) {
-            throw invalidRequest()
-        }
-        val delivery = giftDeliveryRepository.findByGiftId(requireNotNull(gift.id)) ?: throw invalidRequest()
-
-        gift.status = GiftStatus.UNDELIVERABLE
-        delivery.undeliverableAt = now
-        delivery.undeliverableReason = reason
-        giftPushService.sendUndeliverableToSender(gift.applicationNo, gift.senderMemberId)
-        giftPushService.sendUndeliverableToRecipient(gift.applicationNo, gift.recipientMemberId)
-
-        return GiftOperationStatusResult(gift.applicationNo, gift.status, gift.status.displayName, now)
-    }
-
-    @Transactional
-    fun completeDelivery(applicationNo: String, now: LocalDateTime = LocalDateTime.now()): GiftOperationStatusResult {
-        val gift = giftRepository.findByApplicationNo(applicationNo) ?: throw invalidRequest()
-        if (gift.status != GiftStatus.INSPECTION_COMPLETED) throw invalidRequest()
-        val delivery = giftDeliveryRepository.findByGiftId(requireNotNull(gift.id)) ?: throw invalidRequest()
-
-        gift.status = GiftStatus.DELIVERED
-        delivery.deliveredAt = now
-        giftPushService.sendDeliveredToSender(gift.applicationNo, gift.senderMemberId)
-        giftPushService.sendDeliveredToRecipient(gift.applicationNo, gift.recipientMemberId)
-
-        return GiftOperationStatusResult(gift.applicationNo, gift.status, gift.status.displayName, now)
-    }
-
-    private fun validateCategory(command: GiftCategoryCommand) {
-        if (
-            command.categoryCode.isBlank() ||
-            command.categoryCode.length > 50 ||
-            command.name.isBlank() ||
-            command.name.length > 50 ||
-            !CLASSIFICATION_NUMBER_REGEX.matches(command.classificationNumber) ||
-            !RECEIPT_CODE_REGEX.matches(command.receiptCode) ||
-            command.representativeItem.isBlank() ||
-            command.representativeItem.length > 100
-        ) {
-            throw invalidRequest()
-        }
-    }
-
-    private fun validateSizePrice(command: GiftSizePriceCommand) {
-        if (command.salePriceCan <= 0 || command.salePriceCan > command.basePriceCan) throw invalidRequest()
-    }
-
-    private fun GiftCategory.toResult() = GiftCategoryResult(
-        categoryId = id ?: throw invalidRequest(),
-        classificationNumber = classificationNumber,
-        categoryCode = categoryCode,
-        name = name,
-        receiptCode = receiptCode,
-        representativeItem = representativeItem,
-        requiresDamageWaiver = requiresDamageWaiver,
-        isActive = isActive
-    )
-
-    private fun GiftSizePrice.toResult() = GiftSizePriceResult(
-        sizeCode = sizeCode,
-        sizeName = sizeCode.displayName,
-        basePriceCan = basePriceCan,
-        salePriceCan = salePriceCan,
-        isActive = isActive
-    )
-
-    private fun invalidRequest() = SodaException(messageKey = "common.error.invalid_request")
-
-    private companion object {
-        val UNDELIVERABLE_ALLOWED_STATUSES = setOf(
-            GiftStatus.TRACKING_REGISTERED,
-            GiftStatus.ARRIVED_AT_MAILBOX,
-            GiftStatus.INSPECTION_COMPLETED
-        )
-        val CLASSIFICATION_NUMBER_REGEX = Regex("\\d{3}")
-        val RECEIPT_CODE_REGEX = Regex("[A-Z]{1,9}")
-    }
-}
@@ -1,52 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.application
-
-import kr.co.vividnext.sodalive.common.SodaException
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftApplicationNoSequence
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftApplicationNoSequenceRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategory
-import org.springframework.dao.DataIntegrityViolationException
-import org.springframework.stereotype.Service
-import org.springframework.transaction.PlatformTransactionManager
-import org.springframework.transaction.support.TransactionTemplate
-import java.time.LocalDateTime
-import java.time.ZoneId
-import java.time.format.DateTimeFormatter
-
-@Service
-class GiftApplicationNoGenerator(
-    private val repository: GiftApplicationNoSequenceRepository,
-    transactionManager: PlatformTransactionManager
-) {
-    private val transactionTemplate = TransactionTemplate(transactionManager)
-
-    fun generate(category: GiftCategory, now: LocalDateTime = LocalDateTime.now(SEOUL_ZONE)): String {
-        val categoryId = category.id ?: throw SodaException(messageKey = "common.error.invalid_request")
-        val sequenceDate = now.format(DATE_FORMATTER)
-        for (attempt in 1..MAX_RETRY_COUNT) {
-            try {
-                return transactionTemplate.execute {
-                    val sequence = repository.findByCategoryIdAndSequenceDateForUpdate(categoryId, sequenceDate)
-                        ?: repository.saveAndFlush(
-                            GiftApplicationNoSequence(
-                                categoryId = categoryId,
-                                sequenceDate = sequenceDate,
-                                lastSequence = 0
-                            )
-                        )
-                    sequence.lastSequence += 1
-                    "${category.receiptCode}-${category.classificationNumber}$sequenceDate" +
-                        sequence.lastSequence.toString().padStart(4, '0')
-                } ?: throw SodaException(messageKey = "common.error.invalid_request")
-            } catch (_: DataIntegrityViolationException) {
-                if (attempt == MAX_RETRY_COUNT) throw SodaException(messageKey = "gift.application_no.generate_failed")
-            }
-        }
-        throw SodaException(messageKey = "gift.application_no.generate_failed")
-    }
-
-    companion object {
-        private val SEOUL_ZONE = ZoneId.of("Asia/Seoul")
-        private val DATE_FORMATTER = DateTimeFormatter.ofPattern("yyMMdd")
-        private const val MAX_RETRY_COUNT = 3
-    }
-}
@@ -1,368 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.application
-
-import kr.co.vividnext.sodalive.can.payment.CanPaymentService
-import kr.co.vividnext.sodalive.common.SodaException
-import kr.co.vividnext.sodalive.member.Member
-import kr.co.vividnext.sodalive.member.MemberRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.Gift
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategoryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDelivery
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDeliveryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftReview
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftReviewRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftSizePriceRepository
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftSize
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus
-import org.springframework.data.repository.findByIdOrNull
-import org.springframework.stereotype.Service
-import org.springframework.transaction.annotation.Transactional
-import java.time.LocalDateTime
-
-data class GiftApplicationCommand(
-    val recipientMemberId: Long,
-    val senderName: String,
-    val senderPhoneNumber: String,
-    val senderZipCode: String,
-    val senderAddress: String,
-    val senderAddressDetail: String?,
-    val sizeCode: GiftSize,
-    val categoryId: Long,
-    val senderTermsAgreed: Boolean,
-    val senderPrivacyAgreed: Boolean,
-    val damageWaiverAgreed: Boolean
-)
-
-data class GiftApplicationResult(
-    val applicationNo: String,
-    val status: GiftStatus,
-    val statusName: String,
-    val priceCan: Int,
-    val trackingDeadlineAt: LocalDateTime
-)
-
-data class GiftCancellationResult(
-    val applicationNo: String,
-    val status: GiftStatus,
-    val statusName: String,
-    val priceCan: Int,
-    val canceledAt: LocalDateTime
-)
-
-data class GiftTrackingRegistrationCommand(
-    val courierCompanyName: String,
-    val trackingNumber: String
-)
-
-data class GiftTrackingRegistrationResult(
-    val applicationNo: String,
-    val status: GiftStatus,
-    val statusName: String,
-    val courierCompanyName: String,
-    val trackingNumber: String,
-    val trackingRegisteredAt: LocalDateTime,
-    val recipientAddressDeadlineAt: LocalDateTime
-)
-
-data class GiftRecipientAddressRegistrationCommand(
-    val name: String,
-    val phoneNumber: String,
-    val zipCode: String,
-    val address: String,
-    val addressDetail: String?,
-    val recipientTermsAgreed: Boolean,
-    val recipientPrivacyAgreed: Boolean
-)
-
-data class GiftRecipientAddressRegistrationResult(
-    val applicationNo: String,
-    val status: GiftStatus,
-    val statusName: String,
-    val recipientAddressRegisteredAt: LocalDateTime
-)
-
-data class GiftDeliveryConfirmationResult(
-    val applicationNo: String,
-    val status: GiftStatus,
-    val statusName: String,
-    val deliveredAt: LocalDateTime
-)
-
-data class GiftReviewCommand(
-    val rating: Int,
-    val keywords: List<String>,
-    val comment: String?
-)
-
-data class GiftReviewResult(
-    val reviewId: Long,
-    val applicationNo: String,
-    val rating: Int,
-    val keywords: List<String>,
-    val comment: String?,
-    val createdAt: LocalDateTime?
-)
-
-@Service
-class GiftCommandService(
-    private val giftRepository: GiftRepository,
-    private val deliveryRepository: GiftDeliveryRepository,
-    private val reviewRepository: GiftReviewRepository,
-    private val categoryRepository: GiftCategoryRepository,
-    private val sizePriceRepository: GiftSizePriceRepository,
-    private val memberRepository: MemberRepository,
-    private val applicationNoGenerator: GiftApplicationNoGenerator,
-    private val canPaymentService: CanPaymentService,
-    private val giftPushService: GiftPushService,
-    private val now: () -> LocalDateTime = { LocalDateTime.now() }
-) {
-    @Transactional
-    fun registerGift(member: Member, command: GiftApplicationCommand): GiftApplicationResult {
-        validate(command)
-        val senderMemberId = member.id ?: throw invalidRequest()
-        memberRepository.findCreatorByIdOrNull(command.recipientMemberId) ?: throw invalidRequest()
-        val category = categoryRepository.findByIdOrNull(command.categoryId)?.takeIf { it.isActive } ?: throw invalidRequest()
-        if (category.requiresDamageWaiver && !command.damageWaiverAgreed) throw invalidRequest()
-        val sizePrice = sizePriceRepository.findBySizeCode(command.sizeCode)?.takeIf { it.isActive } ?: throw invalidRequest()
-        val appliedAt = now()
-        val trackingDeadlineAt = appliedAt.plusDays(3)
-        val applicationNo = applicationNoGenerator.generate(category, appliedAt)
-        val canUsageId = canPaymentService.spendGiftCan(
-            senderMemberId,
-            sizePrice.salePriceCan,
-            member.container.ifBlank { "web" }
-        )
-        val gift = giftRepository.save(
-            Gift(
-                applicationNo = applicationNo,
-                senderMemberId = senderMemberId,
-                recipientMemberId = command.recipientMemberId,
-                status = GiftStatus.RECEIVED,
-                sizeCode = command.sizeCode,
-                categoryId = category.id ?: throw invalidRequest(),
-                categoryNameSnapshot = category.name,
-                salePriceCan = sizePrice.salePriceCan,
-                canUsageId = canUsageId,
-                senderTermsAgreed = command.senderTermsAgreed,
-                senderPrivacyAgreed = command.senderPrivacyAgreed,
-                senderTermsAgreedAt = appliedAt,
-                senderPrivacyAgreedAt = appliedAt,
-                damageWaiverAgreed = command.damageWaiverAgreed
-            )
-        )
-        deliveryRepository.save(
-            GiftDelivery(
-                giftId = gift.id ?: throw invalidRequest(),
-                senderName = command.senderName,
-                senderPhoneNumber = command.senderPhoneNumber,
-                senderZipCode = command.senderZipCode,
-                senderAddress = command.senderAddress,
-                senderAddressDetail = command.senderAddressDetail,
-                trackingDeadlineAt = trackingDeadlineAt
-            )
-        )
-        return GiftApplicationResult(
-            applicationNo = applicationNo,
-            status = GiftStatus.RECEIVED,
-            statusName = GiftStatus.RECEIVED.displayName,
-            priceCan = sizePrice.salePriceCan,
-            trackingDeadlineAt = trackingDeadlineAt
-        )
-    }
-
-    @Transactional
-    fun writeReview(member: Member, applicationNo: String, command: GiftReviewCommand): GiftReviewResult {
-        val senderMemberId = member.id ?: throw invalidRequest()
-        val gift = giftRepository.findByApplicationNo(applicationNo) ?: throw invalidRequest()
-        val giftId = gift.id ?: throw invalidRequest()
-        if (
-            gift.senderMemberId != senderMemberId ||
-            gift.status != GiftStatus.DELIVERED ||
-            reviewRepository.findByGiftId(giftId) != null
-        ) {
-            throw invalidRequest()
-        }
-        validate(command)
-
-        val review = reviewRepository.save(
-            GiftReview(
-                giftId = giftId,
-                senderMemberId = senderMemberId,
-                rating = command.rating,
-                keywords = command.keywords.joinToString(","),
-                comment = command.comment
-            )
-        )
-
-        return GiftReviewResult(
-            reviewId = review.id ?: throw invalidRequest(),
-            applicationNo = gift.applicationNo,
-            rating = review.rating,
-            keywords = review.keywords?.takeIf { it.isNotBlank() }?.split(",") ?: emptyList(),
-            comment = review.comment,
-            createdAt = review.createdAt
-        )
-    }
-
-    @Transactional
-    fun cancelGift(member: Member, applicationNo: String): GiftCancellationResult {
-        val senderMemberId = member.id ?: throw invalidRequest()
-        val gift = giftRepository.findByApplicationNo(applicationNo) ?: throw invalidRequest()
-        if (gift.senderMemberId != senderMemberId || gift.status != GiftStatus.RECEIVED) throw invalidRequest()
-
-        val canceledAt = now()
-        gift.status = GiftStatus.CANCELED
-        deliveryRepository.findByGiftId(gift.id ?: throw invalidRequest())?.canceledAt = canceledAt
-        canPaymentService.refundGiftCan(senderMemberId, gift.canUsageId)
-
-        return GiftCancellationResult(
-            applicationNo = gift.applicationNo,
-            status = gift.status,
-            statusName = gift.status.displayName,
-            priceCan = gift.salePriceCan,
-            canceledAt = canceledAt
-        )
-    }
-
-    @Transactional
-    fun registerTracking(
-        member: Member,
-        applicationNo: String,
-        command: GiftTrackingRegistrationCommand
-    ): GiftTrackingRegistrationResult {
-        val senderMemberId = member.id ?: throw invalidRequest()
-        val gift = giftRepository.findByApplicationNo(applicationNo) ?: throw invalidRequest()
-        if (gift.senderMemberId != senderMemberId || gift.status != GiftStatus.RECEIVED) throw invalidRequest()
-        validate(command)
-        val delivery = deliveryRepository.findByGiftId(gift.id ?: throw invalidRequest()) ?: throw invalidRequest()
-        val trackingRegisteredAt = now()
-        val recipientAddressDeadlineAt = trackingRegisteredAt.plusDays(7)
-
-        gift.status = GiftStatus.TRACKING_REGISTERED
-        delivery.courierCompanyName = command.courierCompanyName
-        delivery.trackingNumber = command.trackingNumber
-        delivery.trackingRegisteredAt = trackingRegisteredAt
-        delivery.recipientAddressDeadlineAt = recipientAddressDeadlineAt
-        giftPushService.sendTrackingRegisteredToRecipient(gift.applicationNo, gift.recipientMemberId)
-
-        return GiftTrackingRegistrationResult(
-            applicationNo = gift.applicationNo,
-            status = gift.status,
-            statusName = gift.status.displayName,
-            courierCompanyName = command.courierCompanyName,
-            trackingNumber = command.trackingNumber,
-            trackingRegisteredAt = trackingRegisteredAt,
-            recipientAddressDeadlineAt = recipientAddressDeadlineAt
-        )
-    }
-
-    @Transactional
-    fun registerRecipientAddress(
-        member: Member,
-        applicationNo: String,
-        command: GiftRecipientAddressRegistrationCommand
-    ): GiftRecipientAddressRegistrationResult {
-        val recipientMemberId = member.id ?: throw invalidRequest()
-        val gift = giftRepository.findByApplicationNo(applicationNo) ?: throw invalidRequest()
-        if (gift.recipientMemberId != recipientMemberId || gift.status !in RECIPIENT_ADDRESS_REGISTRABLE_STATUSES) {
-            throw invalidRequest()
-        }
-        validate(command)
-        val delivery = deliveryRepository.findByGiftId(gift.id ?: throw invalidRequest()) ?: throw invalidRequest()
-        val registeredAt = now()
-
-        delivery.recipientName = command.name
-        delivery.recipientPhoneNumber = command.phoneNumber
-        delivery.recipientZipCode = command.zipCode
-        delivery.recipientAddress = command.address
-        delivery.recipientAddressDetail = command.addressDetail
-        gift.recipientTermsAgreed = command.recipientTermsAgreed
-        gift.recipientPrivacyAgreed = command.recipientPrivacyAgreed
-        gift.recipientTermsAgreedAt = registeredAt
-        gift.recipientPrivacyAgreedAt = registeredAt
-
-        return GiftRecipientAddressRegistrationResult(
-            applicationNo = gift.applicationNo,
-            status = gift.status,
-            statusName = gift.status.displayName,
-            recipientAddressRegisteredAt = registeredAt
-        )
-    }
-
-    @Transactional
-    fun confirmDelivery(member: Member, applicationNo: String): GiftDeliveryConfirmationResult {
-        val recipientMemberId = member.id ?: throw invalidRequest()
-        val gift = giftRepository.findByApplicationNo(applicationNo) ?: throw invalidRequest()
-        if (gift.recipientMemberId != recipientMemberId || gift.status != GiftStatus.INSPECTION_COMPLETED) {
-            throw invalidRequest()
-        }
-        val delivery = deliveryRepository.findByGiftId(gift.id ?: throw invalidRequest()) ?: throw invalidRequest()
-        val deliveredAt = now()
-
-        gift.status = GiftStatus.DELIVERED
-        delivery.deliveredAt = deliveredAt
-
-        return GiftDeliveryConfirmationResult(
-            applicationNo = gift.applicationNo,
-            status = gift.status,
-            statusName = gift.status.displayName,
-            deliveredAt = deliveredAt
-        )
-    }
-
-    private fun validate(command: GiftApplicationCommand) {
-        if (
-            command.senderName.isBlank() ||
-            command.senderPhoneNumber.isBlank() ||
-            command.senderZipCode.isBlank() ||
-            command.senderAddress.isBlank() ||
-            !command.senderTermsAgreed ||
-            !command.senderPrivacyAgreed
-        ) {
-            throw invalidRequest()
-        }
-    }
-
-    private fun validate(command: GiftTrackingRegistrationCommand) {
-        if (
-            command.courierCompanyName.isBlank() ||
-            command.courierCompanyName.length > 50 ||
-            command.trackingNumber.isBlank()
-        ) {
-            throw invalidRequest()
-        }
-    }
-
-    private fun validate(command: GiftRecipientAddressRegistrationCommand) {
-        if (
-            command.name.isBlank() ||
-            command.phoneNumber.isBlank() ||
-            command.zipCode.isBlank() ||
-            command.address.isBlank() ||
-            !command.recipientTermsAgreed ||
-            !command.recipientPrivacyAgreed
-        ) {
-            throw invalidRequest()
-        }
-    }
-
-    private fun validate(command: GiftReviewCommand) {
-        if (
-            command.rating !in 1..5 ||
-            command.keywords.any { it.length > 255 } ||
-            (command.comment?.length ?: 0) > 255
-        ) {
-            throw invalidRequest()
-        }
-    }
-
-    private fun invalidRequest() = SodaException(messageKey = "common.error.invalid_request")
-
-    private companion object {
-        val RECIPIENT_ADDRESS_REGISTRABLE_STATUSES = setOf(
-            GiftStatus.TRACKING_REGISTERED,
-            GiftStatus.ARRIVED_AT_MAILBOX,
-            GiftStatus.INSPECTION_COMPLETED
-        )
-    }
-}
@@ -1,126 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.application
-
-import kr.co.vividnext.sodalive.fcm.FcmDeepLinkValue
-import kr.co.vividnext.sodalive.fcm.FcmEvent
-import kr.co.vividnext.sodalive.fcm.FcmEventType
-import kr.co.vividnext.sodalive.fcm.notification.PushNotificationCategory
-import org.springframework.context.ApplicationEventPublisher
-import org.springframework.stereotype.Service
-
-@Service
-class GiftPushService(
-    private val applicationEventPublisher: ApplicationEventPublisher
-) {
-    fun sendTrackingDeadlineReminder(applicationNo: String, memberId: Long) {
-        publishGiftPush(
-            memberId = memberId,
-            applicationNo = applicationNo,
-            title = "운송장 번호를 입력해 주세요",
-            message = "24시간 이내에 운송장 번호를 등록해 주세요.\n기한 내 등록하지 않으면 신청이 자동 취소됩니다."
-        )
-    }
-
-    fun sendRecipientAddressDeadlineReminder(applicationNo: String, memberId: Long) {
-        publishGiftPush(
-            memberId = memberId,
-            applicationNo = applicationNo,
-            title = "배송지 입력 기한이 1일 남았어요",
-            message = "24시간 안에 배송지를 입력해 주세요.\n입력하지 않으면 선물은 반송되지 않고 폐기돼요"
-        )
-    }
-
-    fun sendAutoCanceledToSender(applicationNo: String, memberId: Long) {
-        publishGiftPush(
-            memberId = memberId,
-            applicationNo = applicationNo,
-            title = "선물 신청이 자동 취소됐어요",
-            message = "신청 후 3일 이내에 운송장 번호가 등록되지 않아 신청이 취소됐어요.\n사용한 캔은 모두 환불되었습니다."
-        )
-    }
-
-    fun sendTrackingRegisteredToRecipient(applicationNo: String, memberId: Long) {
-        publishGiftPush(
-            memberId = memberId,
-            applicationNo = applicationNo,
-            title = "팬이 보낸 선물이 있어요!",
-            message = "7일 이내에 배송지를 입력해 주세요.\n기간이 지나면 선물을 받을 수 없어요"
-        )
-    }
-
-    fun sendArrivedAtMailboxToSender(applicationNo: String, memberId: Long) {
-        publishGiftPush(
-            memberId = memberId,
-            applicationNo = applicationNo,
-            title = "선물이 사서함에 도착했어요",
-            message = "보내주신 선물이 소다라이브 사서함에 도착했어요.\n안전하게 전달할 수 있도록 선물을 확인하고 있어요."
-        )
-    }
-
-    fun sendArrivedAtMailboxToRecipient(applicationNo: String, memberId: Long) {
-        publishGiftPush(
-            memberId = memberId,
-            applicationNo = applicationNo,
-            title = "선물이 사서함에 도착했어요",
-            message = "팬이 보낸 선물을 검수하고 있어요.\n검수가 끝나면 다시 알려드릴게요"
-        )
-    }
-
-    fun sendInspectionCompleted(applicationNo: String, memberId: Long) {
-        publishGiftPush(
-            memberId = memberId,
-            applicationNo = applicationNo,
-            title = "선물 검수가 완료됐어요",
-            message = "확인된 선물을 빠른 시일 내에 입력하신 배송지로 보내드릴게요."
-        )
-    }
-
-    fun sendUndeliverableToSender(applicationNo: String, memberId: Long) {
-        publishGiftPush(
-            memberId = memberId,
-            applicationNo = applicationNo,
-            title = "선물을 전달할 수 없어요",
-            message = "도착한 선물이 선물 접수 규격에 맞지 않아 크리에이터에게 전달할 수 없어요.\n자세한 사유는 신청 상세에서 확인해 주세요."
-        )
-    }
-
-    fun sendUndeliverableToRecipient(applicationNo: String, memberId: Long) {
-        publishGiftPush(
-            memberId = memberId,
-            applicationNo = applicationNo,
-            title = "전달할 수 없는 선물이 있어요",
-            message = "검수 결과 선물 정책에 맞지 않아 해당 선물은 배송되지 않아요.\n자세한 사유를 확인해 주세요."
-        )
-    }
-
-    fun sendDeliveredToSender(applicationNo: String, memberId: Long) {
-        publishGiftPush(
-            memberId = memberId,
-            applicationNo = applicationNo,
-            title = "선물이 전달됐어요",
-            message = "보내주신 선물이 크리에이터에게 안전하게 전달됐어요."
-        )
-    }
-
-    fun sendDeliveredToRecipient(applicationNo: String, memberId: Long) {
-        publishGiftPush(
-            memberId = memberId,
-            applicationNo = applicationNo,
-            title = "선물이 도착했어요!",
-            message = "팬이 보낸 선물이 배송지에 도착했어요.\n지금 확인해 보세요."
-        )
-    }
-
-    private fun publishGiftPush(memberId: Long, applicationNo: String, title: String, message: String) {
-        applicationEventPublisher.publishEvent(
-            FcmEvent(
-                type = FcmEventType.INDIVIDUAL,
-                category = PushNotificationCategory.GIFT,
-                title = title,
-                message = message,
-                deepLinkValue = FcmDeepLinkValue.GIFT_DETAIL,
-                deepLinkId = applicationNo,
-                recipients = listOf(memberId)
-            )
-        )
-    }
-}
@@ -1,268 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.application
-
-import kr.co.vividnext.sodalive.common.SodaException
-import kr.co.vividnext.sodalive.member.MemberRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.Gift
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategoryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDelivery
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDeliveryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftSizePriceRepository
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftDirection
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftListType
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus
-import org.springframework.data.domain.PageRequest
-import org.springframework.data.domain.Sort
-import org.springframework.data.repository.findByIdOrNull
-import org.springframework.stereotype.Service
-import org.springframework.transaction.annotation.Transactional
-import java.time.LocalDateTime
-
-data class GiftFormOptionsResult(
-    val sizes: List<GiftSizePriceResult>,
-    val categories: List<GiftCategoryResult>
-)
-
-data class GiftListResult(
-    val totalCount: Long,
-    val items: List<GiftListItemResult>,
-    val page: Int,
-    val size: Int,
-    val hasNext: Boolean
-)
-
-data class GiftListItemResult(
-    val applicationNo: String,
-    val direction: GiftDirection,
-    val status: GiftStatus,
-    val statusName: String,
-    val priceCan: Int,
-    val categoryName: String,
-    val sizeName: String,
-    val createdAt: LocalDateTime?
-)
-
-data class GiftDetailResult(
-    val applicationNo: String,
-    val direction: GiftDirection,
-    val status: GiftStatus,
-    val statusName: String,
-    val giftInfo: GiftDetailInfoResult,
-    val senderInfo: GiftAddressResult?,
-    val recipientAddress: GiftAddressResult?,
-    val mailbox: GiftMailboxResult?,
-    val trackingRequired: Boolean,
-    val recipientAddressRequired: Boolean,
-    val recipientAddressDeadlineAt: LocalDateTime?,
-    val delivery: GiftDeliveryInfoResult,
-    val statusTimeline: List<GiftStatusTimelineResult>
-)
-
-data class GiftDetailInfoResult(
-    val recipientCreatorNickname: String?,
-    val senderNickname: String?,
-    val sizeName: String,
-    val categoryName: String,
-    val applicationNo: String?,
-    val paidCan: Int?,
-    val tracking: String?,
-    val shippingRequestedAt: LocalDateTime?
-)
-
-data class GiftAddressResult(
-    val name: String,
-    val phoneNumber: String,
-    val address: String
-)
-
-data class GiftMailboxResult(
-    val name: String,
-    val address: String,
-    val phoneNumber: String
-)
-
-data class GiftDeliveryInfoResult(
-    val canceledAt: LocalDateTime?,
-    val undeliverableAt: LocalDateTime?,
-    val undeliverableReason: String?
-)
-
-data class GiftStatusTimelineResult(
-    val status: GiftStatus,
-    val statusName: String,
-    val occurredAt: LocalDateTime?
-)
-
-@Service
-class GiftQueryService(
-    private val categoryRepository: GiftCategoryRepository,
-    private val sizePriceRepository: GiftSizePriceRepository,
-    private val giftRepository: GiftRepository,
-    private val deliveryRepository: GiftDeliveryRepository,
-    private val memberRepository: MemberRepository
-) {
-    @Transactional(readOnly = true)
-    fun getFormOptions() = GiftFormOptionsResult(
-        sizes = sizePriceRepository.findAll().filter { it.isActive }.map {
-            GiftSizePriceResult(it.sizeCode, it.sizeCode.displayName, it.basePriceCan, it.salePriceCan, it.isActive)
-        },
-        categories = categoryRepository.findAll().filter { it.isActive }.map {
-            GiftCategoryResult(
-                categoryId = it.id!!,
-                classificationNumber = it.classificationNumber,
-                categoryCode = it.categoryCode,
-                name = "${it.name}/${it.representativeItem}",
-                receiptCode = it.receiptCode,
-                representativeItem = it.representativeItem,
-                requiresDamageWaiver = it.requiresDamageWaiver,
-                isActive = it.isActive
-            )
-        }
-    )
-
-    @Transactional(readOnly = true)
-    fun getGifts(memberId: Long, type: GiftListType, page: Int, size: Int): GiftListResult {
-        val normalizedPage = page.coerceAtLeast(0)
-        val normalizedSize = if (size <= 0) DEFAULT_PAGE_SIZE else size
-        val pageable = PageRequest.of(normalizedPage, normalizedSize, Sort.by(Sort.Direction.DESC, "createdAt", "id"))
-        val gifts = when (type) {
-            GiftListType.SENT -> giftRepository.findBySenderMemberId(memberId, pageable)
-            GiftListType.RECEIVED -> giftRepository.findByRecipientMemberIdAndStatusIn(
-                memberId,
-                RECIPIENT_VISIBLE_STATUSES,
-                pageable
-            )
-            GiftListType.ALL -> giftRepository.findBySenderMemberIdOrRecipientMemberIdAndStatusIn(
-                memberId,
-                memberId,
-                RECIPIENT_VISIBLE_STATUSES,
-                pageable
-            )
-        }
-
-        return GiftListResult(
-            totalCount = gifts.totalElements,
-            items = gifts.content.map { it.toGiftListItem(memberId) },
-            page = normalizedPage,
-            size = normalizedSize,
-            hasNext = gifts.hasNext()
-        )
-    }
-
-    @Transactional(readOnly = true)
-    fun getGiftDetail(memberId: Long, applicationNo: String): GiftDetailResult {
-        val gift = giftRepository.findByApplicationNo(applicationNo) ?: throw invalidRequest()
-        val delivery = deliveryRepository.findByGiftId(gift.id ?: throw invalidRequest()) ?: throw invalidRequest()
-        val direction = gift.directionFor(memberId)
-        val sender = memberRepository.findByIdOrNull(gift.senderMemberId) ?: throw invalidRequest()
-        val recipient = memberRepository.findByIdOrNull(gift.recipientMemberId) ?: throw invalidRequest()
-        val recipientAddress = if (direction == GiftDirection.RECEIVED) delivery.toRecipientAddressResult() else null
-
-        return GiftDetailResult(
-            applicationNo = gift.applicationNo,
-            direction = direction,
-            status = gift.status,
-            statusName = gift.status.displayName,
-            giftInfo = GiftDetailInfoResult(
-                recipientCreatorNickname = recipient.nickname.takeIf { direction == GiftDirection.SENT },
-                senderNickname = sender.nickname.takeIf { direction == GiftDirection.RECEIVED },
-                sizeName = gift.sizeCode.displayName,
-                categoryName = gift.categoryNameSnapshot,
-                applicationNo = gift.applicationNo.takeIf { direction == GiftDirection.SENT },
-                paidCan = gift.salePriceCan.takeIf { direction == GiftDirection.SENT },
-                tracking = delivery.tracking().takeIf { direction == GiftDirection.SENT },
-                shippingRequestedAt = gift.createdAt.takeIf { direction == GiftDirection.RECEIVED }
-            ),
-            senderInfo = delivery.toSenderInfo().takeIf { direction == GiftDirection.SENT },
-            recipientAddress = recipientAddress,
-            mailbox = null,
-            trackingRequired = direction == GiftDirection.SENT && gift.status == GiftStatus.RECEIVED,
-            recipientAddressRequired = direction == GiftDirection.RECEIVED && recipientAddress == null &&
-                gift.status !in TERMINAL_STATUSES,
-            recipientAddressDeadlineAt = delivery.recipientAddressDeadlineAt,
-            delivery = GiftDeliveryInfoResult(
-                canceledAt = delivery.canceledAt,
-                undeliverableAt = delivery.undeliverableAt,
-                undeliverableReason = delivery.undeliverableReason
-            ),
-            statusTimeline = gift.toStatusTimeline(delivery)
-        )
-    }
-
-    private fun Gift.toGiftListItem(memberId: Long) = GiftListItemResult(
-        applicationNo = applicationNo,
-        direction = if (senderMemberId == memberId) GiftDirection.SENT else GiftDirection.RECEIVED,
-        status = status,
-        statusName = status.displayName,
-        priceCan = salePriceCan,
-        categoryName = categoryNameSnapshot,
-        sizeName = sizeCode.displayName,
-        createdAt = createdAt
-    )
-
-    private fun Gift.directionFor(memberId: Long) = when {
-        senderMemberId == memberId -> GiftDirection.SENT
-        recipientMemberId == memberId && status in RECIPIENT_VISIBLE_STATUSES -> GiftDirection.RECEIVED
-        else -> throw invalidRequest()
-    }
-
-    private fun GiftDelivery.toSenderInfo() = GiftAddressResult(
-        name = senderName,
-        phoneNumber = senderPhoneNumber,
-        address = formatAddress(senderZipCode, senderAddress, senderAddressDetail)
-    )
-
-    private fun GiftDelivery.toRecipientAddressResult(): GiftAddressResult? {
-        val name = recipientName ?: return null
-        val phoneNumber = recipientPhoneNumber ?: return null
-        val zipCode = recipientZipCode ?: return null
-        val address = recipientAddress ?: return null
-
-        return GiftAddressResult(name, phoneNumber, formatAddress(zipCode, address, recipientAddressDetail))
-    }
-
-    private fun GiftDelivery.tracking() = if (courierCompanyName != null && trackingNumber != null) {
-        "${courierCompanyName}_$trackingNumber"
-    } else {
-        null
-    }
-
-    private fun Gift.toStatusTimeline(delivery: GiftDelivery) = NORMAL_PROGRESS_STATUSES.map { timelineStatus ->
-        GiftStatusTimelineResult(
-            status = timelineStatus,
-            statusName = timelineStatus.displayName,
-            occurredAt = when (timelineStatus) {
-                GiftStatus.RECEIVED -> createdAt
-                GiftStatus.TRACKING_REGISTERED -> delivery.trackingRegisteredAt
-                GiftStatus.ARRIVED_AT_MAILBOX -> delivery.arrivedAtMailboxAt
-                GiftStatus.INSPECTION_COMPLETED -> delivery.inspectionCompletedAt
-                GiftStatus.DELIVERED -> delivery.deliveredAt
-                GiftStatus.UNDELIVERABLE, GiftStatus.CANCELED -> null
-            }
-        )
-    }
-
-    private fun formatAddress(zipCode: String, address: String, detail: String?) =
-        "($zipCode) $address" + if (detail.isNullOrBlank()) "" else ", $detail"
-
-    private fun invalidRequest() = SodaException(messageKey = "common.error.invalid_request")
-
-    private companion object {
-        const val DEFAULT_PAGE_SIZE = 20
-        val RECIPIENT_VISIBLE_STATUSES = setOf(
-            GiftStatus.TRACKING_REGISTERED,
-            GiftStatus.ARRIVED_AT_MAILBOX,
-            GiftStatus.INSPECTION_COMPLETED,
-            GiftStatus.DELIVERED,
-            GiftStatus.UNDELIVERABLE
-        )
-        val NORMAL_PROGRESS_STATUSES = listOf(
-            GiftStatus.RECEIVED,
-            GiftStatus.TRACKING_REGISTERED,
-            GiftStatus.ARRIVED_AT_MAILBOX,
-            GiftStatus.INSPECTION_COMPLETED,
-            GiftStatus.DELIVERED
-        )
-        val TERMINAL_STATUSES = setOf(GiftStatus.DELIVERED, GiftStatus.UNDELIVERABLE, GiftStatus.CANCELED)
-    }
-}
@@ -1,12 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.domain
-
-enum class GiftListType {
-    ALL,
-    SENT,
-    RECEIVED
-}
-
-enum class GiftDirection {
-    SENT,
-    RECEIVED
-}
@@ -1,12 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.domain
-
-enum class GiftSize(
-    val displayName: String,
-    val maxTotalLengthCm: Int,
-    val maxWeightKg: Int,
-    val defaultPriceCan: Int
-) {
-    SMALL("소형", 100, 5, 100),
-    MEDIUM("중형", 120, 15, 150),
-    LARGE("대형", 160, 20, 200)
-}
@@ -1,11 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.domain
-
-enum class GiftStatus(val displayName: String) {
-    RECEIVED("접수 완료"),
-    TRACKING_REGISTERED("발송 확인"),
-    ARRIVED_AT_MAILBOX("사서함 도착"),
-    INSPECTION_COMPLETED("검수 완료"),
-    DELIVERED("전달 완료"),
-    UNDELIVERABLE("전달 불가"),
-    CANCELED("신청 취소")
-}
@@ -1,57 +0,0 @@
-package kr.co.vividnext.sodalive.menu
-
-import kr.co.vividnext.sodalive.member.Member
-import kr.co.vividnext.sodalive.member.MemberRole
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Assertions.assertNull
-import org.junit.jupiter.api.DisplayName
-import org.junit.jupiter.api.Test
-import org.mockito.Mockito
-
-class MenuServiceTest {
-    private val repository = Mockito.mock(MenuRepository::class.java)
-    private val service = MenuService(repository)
-
-    @Test
-    @DisplayName("관리자 메뉴 마지막에 선물함 관리 메뉴를 추가한다")
-    fun shouldAppendGiftMenuForAdmin() {
-        Mockito.`when`(repository.getMenu(MemberRole.ADMIN)).thenReturn(
-            listOf(GetMenuResponse(title = "회원 관리", route = "/member/list"))
-        )
-
-        val menus = service.getMenus(member(MemberRole.ADMIN))
-
-        assertEquals("회원 관리", menus[0].title)
-        val giftMenu = menus.last()
-        assertEquals("선물함 관리", giftMenu.title)
-        assertNull(giftMenu.route)
-        assertEquals(
-            listOf("선물함 리스트", "선물 카테고리", "선물 사이즈"),
-            giftMenu.items?.map { it.title }
-        )
-        assertEquals(
-            listOf("/gift/list", "/gift/category", "/gift/size"),
-            giftMenu.items?.map { it.route }
-        )
-    }
-
-    @Test
-    @DisplayName("관리자가 아니면 선물함 관리 메뉴를 추가하지 않는다")
-    fun shouldNotAppendGiftMenuForNonAdmin() {
-        Mockito.`when`(repository.getMenu(MemberRole.CONTENT_MANAGER)).thenReturn(
-            listOf(GetMenuResponse(title = "콘텐츠 리스트", route = "/content/list"))
-        )
-
-        val menus = service.getMenus(member(MemberRole.CONTENT_MANAGER))
-
-        assertEquals(1, menus.size)
-        assertEquals("콘텐츠 리스트", menus[0].title)
-    }
-
-    private fun member(role: MemberRole) = Member(
-        email = "${role.name.lowercase()}@test.com",
-        password = "password",
-        nickname = role.name.lowercase(),
-        role = role
-    )
-}
@@ -1,391 +0,0 @@
-package kr.co.vividnext.sodalive.v2.api.admin.gift.adapter.`in`.web
-
-import kr.co.vividnext.sodalive.member.Member
-import kr.co.vividnext.sodalive.member.MemberRepository
-import kr.co.vividnext.sodalive.support.EmbeddedRedisInitializer
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.Gift
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategory
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategoryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDelivery
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDeliveryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftSizePrice
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftSizePriceRepository
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftSize
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus
-import org.hamcrest.Matchers.endsWith
-import org.junit.jupiter.api.BeforeEach
-import org.junit.jupiter.api.DisplayName
-import org.junit.jupiter.api.Test
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
-import org.springframework.boot.test.context.SpringBootTest
-import org.springframework.http.MediaType
-import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.user
-import org.springframework.test.annotation.DirtiesContext
-import org.springframework.test.context.ContextConfiguration
-import org.springframework.test.web.servlet.MockMvc
-import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete
-import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
-import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post
-import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put
-import org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath
-import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
-import java.time.LocalDateTime
-
-@SpringBootTest(
-    properties = [
-        "cloud.aws.cloud-front.host=https://cdn.test",
-        "spring.datasource.url=jdbc:h2:mem:gift-admin-controller;MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;" +
-            "DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE"
-    ]
-)
-@AutoConfigureMockMvc
-@ContextConfiguration(initializers = [EmbeddedRedisInitializer::class])
-@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_CLASS)
-@DisplayName("선물 관리자 API 테스트")
-class AdminGiftControllerTest @Autowired constructor(
-    private val mockMvc: MockMvc,
-    private val categoryRepository: GiftCategoryRepository,
-    private val sizePriceRepository: GiftSizePriceRepository,
-    private val giftRepository: GiftRepository,
-    private val giftDeliveryRepository: GiftDeliveryRepository,
-    private val memberRepository: MemberRepository
-) {
-    @BeforeEach
-    fun deleteGiftFixtures() {
-        giftDeliveryRepository.deleteAll()
-        giftRepository.deleteAll()
-        categoryRepository.deleteAll()
-    }
-
-    @Test
-    @DisplayName("관리자는 전체 선물함 목록을 필터링해 조회한다")
-    fun shouldListAdminGifts() {
-        val (gift, _) = saveAdminGift(
-            applicationNo = "A-1002609300001",
-            status = GiftStatus.TRACKING_REGISTERED,
-            senderNickname = "admin-fan-alpha",
-            recipientNickname = "admin-creator-alpha",
-            withTracking = true
-        )
-
-        mockMvc.perform(
-            get("/api/v2/admin/gifts")
-                .with(user("admin").roles("ADMIN"))
-                .param("status", "TRACKING_REGISTERED")
-                .param("applicationNo", "0001")
-                .param("nickname", "alpha")
-                .param("page", "0")
-                .param("size", "20")
-        )
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(true))
-            .andExpect(jsonPath("$.data.totalCount").value(1))
-            .andExpect(jsonPath("$.data.items[0].applicationNo").value(gift.applicationNo))
-            .andExpect(jsonPath("$.data.items[0].senderNickname").value("admin-fan-alpha"))
-            .andExpect(jsonPath("$.data.items[0].recipientNickname").value("admin-creator-alpha"))
-            .andExpect(jsonPath("$.data.items[0].sizeCode").value("SMALL"))
-            .andExpect(jsonPath("$.data.items[0].sizeName").value("소형"))
-            .andExpect(jsonPath("$.data.items[0].categoryName").value("인형"))
-            .andExpect(jsonPath("$.data.items[0].classificationNumber").value("100"))
-            .andExpect(jsonPath("$.data.items[0].courierCompanyName").value("CJ대한통운"))
-            .andExpect(jsonPath("$.data.items[0].trackingNumber").value("1234567890"))
-            .andExpect(jsonPath("$.data.items[0].status").value("TRACKING_REGISTERED"))
-            .andExpect(jsonPath("$.data.items[0].statusName").value("발송 확인"))
-            .andExpect(jsonPath("$.data.items[0].availableActions[0]").value("ARRIVE_MAILBOX"))
-            .andExpect(jsonPath("$.data.items[0].availableActions[1]").value("MARK_UNDELIVERABLE"))
-            .andExpect(jsonPath("$.data.page").value(0))
-            .andExpect(jsonPath("$.data.size").value(20))
-            .andExpect(jsonPath("$.data.hasNext").value(false))
-    }
-
-    @Test
-    @DisplayName("관리자는 선물 상세를 조회하고 미입력 수취인 정보는 빈 문자열로 받는다")
-    fun shouldGetAdminGiftDetail() {
-        saveAdminGift(
-            applicationNo = "A-1002609300002",
-            status = GiftStatus.ARRIVED_AT_MAILBOX,
-            senderNickname = "admin-fan-beta",
-            recipientNickname = "admin-creator-beta",
-            withTracking = true
-        )
-
-        mockMvc.perform(
-            get("/api/v2/admin/gifts/A-1002609300002")
-                .with(user("admin").roles("ADMIN"))
-        )
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(true))
-            .andExpect(jsonPath("$.data.applicationNo").value("A-1002609300002"))
-            .andExpect(jsonPath("$.data.senderInfo.nickname").value("admin-fan-beta"))
-            .andExpect(jsonPath("$.data.senderInfo.name").value("홍길동"))
-            .andExpect(jsonPath("$.data.senderInfo.phoneNumber").value("01012345678"))
-            .andExpect(jsonPath("$.data.senderInfo.address").value("(06234) 서울시 강남구, 101동 1001호"))
-            .andExpect(jsonPath("$.data.recipientInfo.nickname").value("admin-creator-beta"))
-            .andExpect(jsonPath("$.data.recipientInfo.name").value(""))
-            .andExpect(jsonPath("$.data.recipientInfo.phoneNumber").value(""))
-            .andExpect(jsonPath("$.data.recipientInfo.address").value(""))
-            .andExpect(jsonPath("$.data.productInfo.sizeCode").value("SMALL"))
-            .andExpect(jsonPath("$.data.productInfo.sizeName").value("소형"))
-            .andExpect(jsonPath("$.data.productInfo.categoryName").value("인형"))
-            .andExpect(jsonPath("$.data.productInfo.classificationNumber").value("100"))
-            .andExpect(jsonPath("$.data.inboundDeliveryInfo.courierCompanyName").value("CJ대한통운"))
-            .andExpect(jsonPath("$.data.inboundDeliveryInfo.trackingNumber").value("1234567890"))
-            .andExpect(jsonPath("$.data.status").value("ARRIVED_AT_MAILBOX"))
-            .andExpect(jsonPath("$.data.statusName").value("사서함 도착"))
-            .andExpect(jsonPath("$.data.availableActions[0]").value("COMPLETE_INSPECTION"))
-            .andExpect(jsonPath("$.data.availableActions[1]").value("MARK_UNDELIVERABLE"))
-    }
-
-    @Test
-    @DisplayName("관리자는 카테고리를 등록, 조회, 수정, 논리삭제한다")
-    fun shouldManageGiftCategories() {
-        mockMvc.perform(
-            post("/api/v2/admin/gift-categories")
-                .with(user("admin").roles("ADMIN"))
-                .contentType(MediaType.APPLICATION_JSON)
-                .content(
-                    """
-                    {
-                      "classificationNumber":"100",
-                      "categoryCode":"DOLL",
-                      "name":"인형",
-                      "receiptCode":"A",
-                      "representativeItem":"피규어",
-                      "requiresDamageWaiver":true,
-                      "isActive":true
-                    }
-                    """.trimIndent()
-                )
-        )
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(true))
-            .andExpect(jsonPath("$.data.classificationNumber").value("100"))
-            .andExpect(jsonPath("$.data.categoryCode").value("DOLL"))
-            .andExpect(jsonPath("$.data.receiptCode").value("A"))
-            .andExpect(jsonPath("$.data.representativeItem").value("피규어"))
-
-        val categoryId = categoryRepository.findByCategoryCode("DOLL")!!.id!!
-
-        mockMvc.perform(
-            put("/api/v2/admin/gift-categories/$categoryId")
-                .with(user("admin").roles("ADMIN"))
-                .contentType(MediaType.APPLICATION_JSON)
-                .content(
-                    """
-                    {
-                      "classificationNumber":"101",
-                      "categoryCode":"DOLL",
-                      "name":"큰 인형",
-                      "receiptCode":"B",
-                      "representativeItem":"대형 피규어",
-                      "requiresDamageWaiver":false,
-                      "isActive":true
-                    }
-                    """.trimIndent()
-                )
-        )
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.data.classificationNumber").value("101"))
-            .andExpect(jsonPath("$.data.name").value("큰 인형"))
-            .andExpect(jsonPath("$.data.receiptCode").value("B"))
-            .andExpect(jsonPath("$.data.representativeItem").value("대형 피규어"))
-
-        mockMvc.perform(get("/api/v2/admin/gift-categories").with(user("admin").roles("ADMIN")))
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.data[0].name").value("큰 인형"))
-
-        mockMvc.perform(delete("/api/v2/admin/gift-categories/$categoryId").with(user("admin").roles("ADMIN")))
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.data.isActive").value(false))
-    }
-
-    @Test
-    @DisplayName("관리자는 사이즈 가격을 조회하고 수정하며 잘못된 가격을 거부한다")
-    fun shouldManageGiftSizePrices() {
-        sizePriceRepository.save(GiftSizePrice(sizeCode = GiftSize.SMALL, basePriceCan = 100, salePriceCan = 100))
-
-        mockMvc.perform(get("/api/v2/admin/gift-size-prices").with(user("admin").roles("ADMIN")))
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.data[0].sizeCode").value("SMALL"))
-
-        mockMvc.perform(
-            put("/api/v2/admin/gift-size-prices/SMALL")
-                .with(user("admin").roles("ADMIN"))
-                .contentType(MediaType.APPLICATION_JSON)
-                .content("""{"basePriceCan":100,"salePriceCan":80,"isActive":true}""")
-        )
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.data.salePriceCan").value(80))
-
-        mockMvc.perform(
-            put("/api/v2/admin/gift-size-prices/SMALL")
-                .with(user("admin").roles("ADMIN"))
-                .contentType(MediaType.APPLICATION_JSON)
-                .content("""{"basePriceCan":100,"salePriceCan":101,"isActive":true}""")
-        )
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(false))
-    }
-
-    @Test
-    @DisplayName("관리자는 사서함 도착과 검수완료를 처리한다")
-    fun shouldUpdateGiftOperationStatuses() {
-        saveGift(GiftStatus.TRACKING_REGISTERED)
-
-        mockMvc.perform(post("/api/v2/admin/gifts/$APPLICATION_NO/arrive-mailbox").with(user("admin").roles("ADMIN")))
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(true))
-            .andExpect(jsonPath("$.data.applicationNo").value(APPLICATION_NO))
-            .andExpect(jsonPath("$.data.status").value("ARRIVED_AT_MAILBOX"))
-            .andExpect(jsonPath("$.data.occurredAt").value(endsWith("Z")))
-
-        mockMvc.perform(post("/api/v2/admin/gifts/$APPLICATION_NO/complete-inspection").with(user("admin").roles("ADMIN")))
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(true))
-            .andExpect(jsonPath("$.data.status").value("INSPECTION_COMPLETED"))
-            .andExpect(jsonPath("$.data.occurredAt").value(endsWith("Z")))
-    }
-
-    @Test
-    @DisplayName("관리자는 전달불가 사유를 등록하고 전달불가 처리한다")
-    fun shouldMarkGiftUndeliverable() {
-        saveGift(GiftStatus.INSPECTION_COMPLETED)
-
-        mockMvc.perform(
-            post("/api/v2/admin/gifts/$APPLICATION_NO/mark-undeliverable")
-                .with(user("admin").roles("ADMIN"))
-                .contentType(MediaType.APPLICATION_JSON)
-                .content("""{"reason":"선물 접수 규격에 맞지 않습니다."}""")
-        )
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(true))
-            .andExpect(jsonPath("$.data.applicationNo").value(APPLICATION_NO))
-            .andExpect(jsonPath("$.data.status").value("UNDELIVERABLE"))
-            .andExpect(jsonPath("$.data.occurredAt").value(endsWith("Z")))
-    }
-
-    @Test
-    @DisplayName("관리자는 전달불가 사유 없이 전달불가 처리할 수 없다")
-    fun shouldRejectUndeliverableWithoutReason() {
-        saveGift(GiftStatus.INSPECTION_COMPLETED)
-
-        mockMvc.perform(
-            post("/api/v2/admin/gifts/$APPLICATION_NO/mark-undeliverable")
-                .with(user("admin").roles("ADMIN"))
-                .contentType(MediaType.APPLICATION_JSON)
-                .content("""{"reason":" "}""")
-        )
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(false))
-    }
-
-    @Test
-    @DisplayName("관리자는 검수완료 선물을 전달완료 처리한다")
-    fun shouldCompleteGiftDelivery() {
-        saveGift(GiftStatus.INSPECTION_COMPLETED)
-
-        mockMvc.perform(post("/api/v2/admin/gifts/$APPLICATION_NO/complete-delivery").with(user("admin").roles("ADMIN")))
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(true))
-            .andExpect(jsonPath("$.data.applicationNo").value(APPLICATION_NO))
-            .andExpect(jsonPath("$.data.status").value("DELIVERED"))
-            .andExpect(jsonPath("$.data.occurredAt").value(endsWith("Z")))
-    }
-
-    private fun saveGift(status: GiftStatus) {
-        val gift = giftRepository.save(
-            Gift(
-                applicationNo = APPLICATION_NO,
-                senderMemberId = SENDER_MEMBER_ID,
-                recipientMemberId = RECIPIENT_MEMBER_ID,
-                status = status,
-                sizeCode = GiftSize.SMALL,
-                categoryId = 1L,
-                categoryNameSnapshot = "인형",
-                salePriceCan = 80,
-                canUsageId = 10L,
-                senderTermsAgreed = true,
-                senderPrivacyAgreed = true,
-                senderTermsAgreedAt = NOW.minusDays(1),
-                senderPrivacyAgreedAt = NOW.minusDays(1),
-                damageWaiverAgreed = true
-            )
-        )
-        giftDeliveryRepository.save(
-            GiftDelivery(
-                giftId = requireNotNull(gift.id),
-                senderName = "홍길동",
-                senderPhoneNumber = "01012345678",
-                senderZipCode = "06234",
-                senderAddress = "서울시 강남구",
-                trackingDeadlineAt = NOW.minusDays(1),
-                trackingRegisteredAt = NOW.minusHours(1)
-            )
-        )
-    }
-
-    private fun saveAdminGift(
-        applicationNo: String,
-        status: GiftStatus,
-        senderNickname: String,
-        recipientNickname: String,
-        withTracking: Boolean
-    ): Pair<Gift, GiftDelivery> {
-        val sender = memberRepository.save(Member(password = "password", nickname = senderNickname))
-        val recipient = memberRepository.save(Member(password = "password", nickname = recipientNickname))
-        val category = categoryRepository.save(
-            GiftCategory(
-                classificationNumber = "100",
-                categoryCode = "ADMIN_${applicationNo.takeLast(4)}",
-                name = "인형",
-                receiptCode = "A",
-                representativeItem = "피규어"
-            )
-        )
-        val gift = giftRepository.save(
-            Gift(
-                applicationNo = applicationNo,
-                senderMemberId = sender.id!!,
-                recipientMemberId = recipient.id!!,
-                status = status,
-                sizeCode = GiftSize.SMALL,
-                categoryId = category.id!!,
-                categoryNameSnapshot = category.name,
-                salePriceCan = 80,
-                canUsageId = 10L,
-                senderTermsAgreed = true,
-                senderPrivacyAgreed = true,
-                senderTermsAgreedAt = NOW.minusDays(1),
-                senderPrivacyAgreedAt = NOW.minusDays(1),
-                damageWaiverAgreed = true
-            )
-        )
-        val delivery = giftDeliveryRepository.save(
-            GiftDelivery(
-                giftId = requireNotNull(gift.id),
-                senderName = "홍길동",
-                senderPhoneNumber = "01012345678",
-                senderZipCode = "06234",
-                senderAddress = "서울시 강남구",
-                senderAddressDetail = "101동 1001호",
-                trackingDeadlineAt = NOW.minusDays(1)
-            ).apply {
-                if (withTracking) {
-                    courierCompanyName = "CJ대한통운"
-                    trackingNumber = "1234567890"
-                    trackingRegisteredAt = NOW.minusHours(1)
-                }
-            }
-        )
-        return gift to delivery
-    }
-
-    private companion object {
-        const val APPLICATION_NO = "G20260929000001"
-        const val SENDER_MEMBER_ID = 1L
-        const val RECIPIENT_MEMBER_ID = 2L
-        val NOW: LocalDateTime = LocalDateTime.of(2026, 10, 3, 12, 0)
-    }
-}
@@ -1,454 +0,0 @@
-package kr.co.vividnext.sodalive.v2.api.gift.adapter.`in`.web
-
-import com.fasterxml.jackson.databind.ObjectMapper
-import kr.co.vividnext.sodalive.member.Member
-import kr.co.vividnext.sodalive.member.MemberAdapter
-import kr.co.vividnext.sodalive.member.MemberRepository
-import kr.co.vividnext.sodalive.support.EmbeddedRedisInitializer
-import kr.co.vividnext.sodalive.v2.api.gift.dto.GiftApplicationRequest
-import kr.co.vividnext.sodalive.v2.api.gift.dto.GiftRecipientAddressRegistrationRequest
-import kr.co.vividnext.sodalive.v2.api.gift.dto.GiftReviewRequest
-import kr.co.vividnext.sodalive.v2.api.gift.dto.GiftTrackingRegistrationRequest
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.Gift
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategory
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategoryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDelivery
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDeliveryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftSizePrice
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftSizePriceRepository
-import kr.co.vividnext.sodalive.v2.gift.application.GiftApplicationResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftCancellationResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftCommandService
-import kr.co.vividnext.sodalive.v2.gift.application.GiftDeliveryConfirmationResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftRecipientAddressRegistrationResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftReviewResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftTrackingRegistrationResult
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftSize
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus
-import org.hamcrest.Matchers.endsWith
-import org.junit.jupiter.api.DisplayName
-import org.junit.jupiter.api.Test
-import org.mockito.Mockito
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
-import org.springframework.boot.test.context.SpringBootTest
-import org.springframework.boot.test.mock.mockito.MockBean
-import org.springframework.http.MediaType
-import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.user
-import org.springframework.test.context.ContextConfiguration
-import org.springframework.test.web.servlet.MockMvc
-import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
-import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post
-import org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath
-import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
-import java.time.LocalDateTime
-
-@SpringBootTest(
-    properties = [
-        "spring.datasource.url=jdbc:h2:mem:gift-controller;MODE=MySQL;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE"
-    ]
-)
-@AutoConfigureMockMvc
-@ContextConfiguration(initializers = [EmbeddedRedisInitializer::class])
-class GiftControllerTest @Autowired constructor(
-    private val mockMvc: MockMvc,
-    private val categoryRepository: GiftCategoryRepository,
-    private val giftRepository: GiftRepository,
-    private val giftDeliveryRepository: GiftDeliveryRepository,
-    private val sizePriceRepository: GiftSizePriceRepository,
-    private val memberRepository: MemberRepository,
-    private val objectMapper: ObjectMapper
-) {
-    @MockBean
-    private lateinit var commandService: GiftCommandService
-
-    @Test
-    fun `팬은 활성 폼 옵션을 조회하고 categoryCode를 받지 않는다`() {
-        categoryRepository.save(giftCategory("100", "DOLL", "A", "인형", "피규어", true, true))
-        categoryRepository.save(giftCategory("200", "FOOD", "B", "간식", "쿠키", false, false))
-        sizePriceRepository.save(GiftSizePrice(GiftSize.SMALL, 100, 80, true))
-
-        mockMvc.perform(get("/api/v2/gifts/form-options").with(user("fan").roles("USER")))
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(true))
-            .andExpect(jsonPath("$.data.sizes[0].sizeCode").value("SMALL"))
-            .andExpect(jsonPath("$.data.sizes[0].name").value("소형"))
-            .andExpect(jsonPath("$.data.sizes[0].basePriceCan").value(100))
-            .andExpect(jsonPath("$.data.sizes[0].salePriceCan").value(80))
-            .andExpect(jsonPath("$.data.categories[0].name").value("인형/피규어"))
-            .andExpect(jsonPath("$.data.categories[0].categoryCode").doesNotExist())
-            .andExpect(jsonPath("$.data.categories[0].classificationNumber").doesNotExist())
-            .andExpect(jsonPath("$.data.categories[0].receiptCode").doesNotExist())
-            .andExpect(jsonPath("$.data.categories[0].representativeItem").doesNotExist())
-    }
-
-    @Test
-    @DisplayName("회원은 선물함 목록에서 보낸 선물과 노출 가능한 받은 선물을 페이징 응답으로 조회한다")
-    fun shouldListGifts() {
-        val member = Member(password = "password", nickname = "member").apply { id = 10L }
-        saveGift("G-CONTROLLER-SENT", senderMemberId = 10L, recipientMemberId = 20L, status = GiftStatus.RECEIVED)
-        saveGift("G-CONTROLLER-HIDDEN", senderMemberId = 20L, recipientMemberId = 10L, status = GiftStatus.RECEIVED)
-        saveGift(
-            "G-CONTROLLER-VISIBLE",
-            senderMemberId = 20L,
-            recipientMemberId = 10L,
-            status = GiftStatus.TRACKING_REGISTERED
-        )
-
-        mockMvc.perform(
-            get("/api/v2/gifts")
-                .param("type", "ALL")
-                .param("page", "-1")
-                .param("size", "0")
-                .with(user(MemberAdapter(member)))
-        )
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(true))
-            .andExpect(jsonPath("$.data.totalCount").value(2))
-            .andExpect(jsonPath("$.data.items.length()").value(2))
-            .andExpect(jsonPath("$.data.page").value(0))
-            .andExpect(jsonPath("$.data.size").value(20))
-            .andExpect(jsonPath("$.data.hasNext").value(false))
-            .andExpect(jsonPath("$.data.items[0].applicationNo").value("G-CONTROLLER-VISIBLE"))
-            .andExpect(jsonPath("$.data.items[0].direction").value("RECEIVED"))
-            .andExpect(jsonPath("$.data.items[0].status").value("TRACKING_REGISTERED"))
-            .andExpect(jsonPath("$.data.items[0].statusName").value("발송 확인"))
-            .andExpect(jsonPath("$.data.items[0].priceCan").value(80))
-            .andExpect(jsonPath("$.data.items[0].categoryName").value("인형"))
-            .andExpect(jsonPath("$.data.items[0].sizeName").value("소형"))
-            .andExpect(jsonPath("$.data.items[0].createdAt").value(endsWith("Z")))
-    }
-
-    @Test
-    @DisplayName("발신자는 인증 정보로 선물 상세와 자신의 발신자 정보를 조회한다")
-    fun shouldGetSentGiftDetail() {
-        val sender = memberRepository.save(Member(password = "password", nickname = "fan"))
-        val recipient = memberRepository.save(Member(password = "password", nickname = "creator"))
-        val gift = saveGift(
-            applicationNo = "G-CONTROLLER-DETAIL",
-            senderMemberId = sender.id!!,
-            recipientMemberId = recipient.id!!,
-            status = GiftStatus.TRACKING_REGISTERED
-        )
-        giftDeliveryRepository.save(
-            GiftDelivery(
-                giftId = gift.id!!,
-                senderName = "홍길동",
-                senderPhoneNumber = "01012345678",
-                senderZipCode = "06234",
-                senderAddress = "서울시 강남구",
-                senderAddressDetail = "101동 1001호",
-                trackingDeadlineAt = LocalDateTime.of(2026, 10, 2, 12, 0)
-            ).apply {
-                courierCompanyName = "CJ대한통운"
-                trackingNumber = "1234567890"
-                trackingRegisteredAt = LocalDateTime.of(2026, 9, 30, 12, 0)
-            }
-        )
-
-        mockMvc.perform(
-            get("/api/v2/gifts/{applicationNo}", gift.applicationNo)
-                .with(user(MemberAdapter(sender)))
-        )
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(true))
-            .andExpect(jsonPath("$.data.applicationNo").value("G-CONTROLLER-DETAIL"))
-            .andExpect(jsonPath("$.data.direction").value("SENT"))
-            .andExpect(jsonPath("$.data.status").value("TRACKING_REGISTERED"))
-            .andExpect(jsonPath("$.data.giftInfo.recipientCreatorNickname").value("creator"))
-            .andExpect(jsonPath("$.data.giftInfo.applicationNo").value("G-CONTROLLER-DETAIL"))
-            .andExpect(jsonPath("$.data.giftInfo.paidCan").value(80))
-            .andExpect(jsonPath("$.data.giftInfo.tracking").value("CJ대한통운_1234567890"))
-            .andExpect(jsonPath("$.data.senderInfo.name").value("홍길동"))
-            .andExpect(jsonPath("$.data.senderInfo.address").value("(06234) 서울시 강남구, 101동 1001호"))
-            .andExpect(jsonPath("$.data.recipientAddress").isEmpty)
-            .andExpect(jsonPath("$.data.trackingRequired").value(false))
-            .andExpect(jsonPath("$.data.statusTimeline[0].status").value("RECEIVED"))
-            .andExpect(jsonPath("$.data.recipientAddressDeadlineAt").isEmpty)
-            .andExpect(jsonPath("$.data.giftInfo.shippingRequestedAt").isEmpty)
-            .andExpect(jsonPath("$.data.delivery.canceledAt").isEmpty)
-            .andExpect(jsonPath("$.data.delivery.undeliverableAt").isEmpty)
-            .andExpect(jsonPath("$.data.statusTimeline[1].occurredAt").value("2026-09-30T12:00:00Z"))
-    }
-
-    @Test
-    @DisplayName("팬은 POST /api/v2/gifts로 선물을 신청하고 접수 결과를 받는다")
-    fun shouldRegisterGift() {
-        // Given: 로그인한 팬과 선물 신청 요청을 준비한다.
-        val member = Member(password = "password", nickname = "fan").apply { id = SENDER_ID }
-        val request = GiftApplicationRequest(
-            recipientMemberId = RECIPIENT_ID,
-            senderName = "홍길동",
-            senderPhoneNumber = "01012345678",
-            senderZipCode = "06234",
-            senderAddress = "서울시 강남구",
-            senderAddressDetail = "101동 1001호",
-            sizeCode = GiftSize.SMALL,
-            categoryId = CATEGORY_ID,
-            senderTermsAgreed = true,
-            senderPrivacyAgreed = true,
-            damageWaiverAgreed = true
-        )
-        val deadline = LocalDateTime.of(2026, 10, 2, 12, 0)
-        Mockito.`when`(
-            commandService.registerGift(member, request.toCommand())
-        ).thenReturn(
-            GiftApplicationResult(
-                applicationNo = "G20260929000001",
-                status = GiftStatus.RECEIVED,
-                statusName = "접수 완료",
-                priceCan = 80,
-                trackingDeadlineAt = deadline
-            )
-        )
-
-        // When: 팬이 선물 신청 API를 호출한다.
-        mockMvc.perform(
-            post("/api/v2/gifts")
-                .with(user(MemberAdapter(member)))
-                .contentType(MediaType.APPLICATION_JSON)
-                .content(objectMapper.writeValueAsString(request))
-        )
-            // Then: 신청번호, 접수 상태, 판매가와 운송장 등록 기한을 반환한다.
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(true))
-            .andExpect(jsonPath("$.data.applicationNo").value("G20260929000001"))
-            .andExpect(jsonPath("$.data.status").value("RECEIVED"))
-            .andExpect(jsonPath("$.data.statusName").value("접수 완료"))
-            .andExpect(jsonPath("$.data.priceCan").value(80))
-            .andExpect(jsonPath("$.data.trackingDeadlineAt").value("2026-10-02T12:00:00Z"))
-    }
-
-    @Test
-    @DisplayName("팬은 POST /api/v2/gifts/{applicationNo}/cancel로 접수된 선물을 취소하고 환불 결과를 받는다")
-    fun shouldCancelGift() {
-        // Given: 취소할 접수 선물과 로그인한 발신자를 준비한다.
-        val member = Member(password = "password", nickname = "fan").apply { id = SENDER_ID }
-        val canceledAt = LocalDateTime.of(2026, 9, 29, 12, 0)
-        Mockito.`when`(commandService.cancelGift(member, APPLICATION_NO)).thenReturn(
-            GiftCancellationResult(
-                applicationNo = APPLICATION_NO,
-                status = GiftStatus.CANCELED,
-                statusName = "신청 취소",
-                priceCan = 80,
-                canceledAt = canceledAt
-            )
-        )
-
-        // When: 발신자 인증으로 취소 API를 호출한다.
-        mockMvc.perform(
-            post("/api/v2/gifts/{applicationNo}/cancel", APPLICATION_NO)
-                .with(user(MemberAdapter(member)))
-        )
-            // Then: 취소 상태, 환불 금액과 취소 시각을 반환한다.
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(true))
-            .andExpect(jsonPath("$.data.applicationNo").value(APPLICATION_NO))
-            .andExpect(jsonPath("$.data.status").value("CANCELED"))
-            .andExpect(jsonPath("$.data.statusName").value("신청 취소"))
-            .andExpect(jsonPath("$.data.priceCan").value(80))
-            .andExpect(jsonPath("$.data.canceledAt").value("2026-09-29T12:00:00Z"))
-    }
-
-    @Test
-    @DisplayName("팬은 POST /api/v2/gifts/{applicationNo}/tracking으로 운송장을 등록하고 발송 확인 결과를 받는다")
-    fun shouldRegisterTracking() {
-        // Given: 운송장 등록 요청과 로그인한 발신자를 준비한다.
-        val member = Member(password = "password", nickname = "fan").apply { id = SENDER_ID }
-        val request = GiftTrackingRegistrationRequest(
-            courierCompanyName = "CJ대한통운",
-            trackingNumber = "1234567890"
-        )
-        val trackingRegisteredAt = LocalDateTime.of(2026, 9, 29, 12, 0)
-        val recipientAddressDeadlineAt = trackingRegisteredAt.plusDays(7)
-        Mockito.`when`(commandService.registerTracking(member, APPLICATION_NO, request.toCommand())).thenReturn(
-            GiftTrackingRegistrationResult(
-                applicationNo = APPLICATION_NO,
-                status = GiftStatus.TRACKING_REGISTERED,
-                statusName = "발송 확인",
-                courierCompanyName = "CJ대한통운",
-                trackingNumber = "1234567890",
-                trackingRegisteredAt = trackingRegisteredAt,
-                recipientAddressDeadlineAt = recipientAddressDeadlineAt
-            )
-        )
-
-        // When: 발신자 인증으로 운송장 등록 API를 호출한다.
-        mockMvc.perform(
-            post("/api/v2/gifts/{applicationNo}/tracking", APPLICATION_NO)
-                .with(user(MemberAdapter(member)))
-                .contentType(MediaType.APPLICATION_JSON)
-                .content(objectMapper.writeValueAsString(request))
-        )
-            // Then: 신청번호, 발송 확인 상태와 운송장 및 수신자 주소 입력 기한을 반환한다.
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(true))
-            .andExpect(jsonPath("$.data.applicationNo").value(APPLICATION_NO))
-            .andExpect(jsonPath("$.data.status").value("TRACKING_REGISTERED"))
-            .andExpect(jsonPath("$.data.statusName").value("발송 확인"))
-            .andExpect(jsonPath("$.data.courierCompanyName").value("CJ대한통운"))
-            .andExpect(jsonPath("$.data.trackingNumber").value("1234567890"))
-            .andExpect(jsonPath("$.data.trackingRegisteredAt").value("2026-09-29T12:00:00Z"))
-            .andExpect(jsonPath("$.data.recipientAddressDeadlineAt").value("2026-10-06T12:00:00Z"))
-    }
-
-    @Test
-    @DisplayName("받는 크리에이터는 POST recipient-address로 주소 등록 성공 envelope를 받는다")
-    fun shouldRegisterRecipientAddress() {
-        // Given: 로그인한 받는 크리에이터와 주소 등록 요청을 준비한다.
-        val member = Member(password = "password", nickname = "creator").apply { id = RECIPIENT_ID }
-        val request = GiftRecipientAddressRegistrationRequest(
-            recipientName = "김소다",
-            recipientPhoneNumber = "01098765432",
-            recipientZipCode = "04524",
-            recipientAddress = "서울시 중구",
-            recipientAddressDetail = "202호",
-            recipientTermsAgreed = true,
-            recipientPrivacyAgreed = true
-        )
-        val registeredAt = LocalDateTime.of(2026, 9, 29, 12, 0)
-        Mockito.`when`(
-            commandService.registerRecipientAddress(member, APPLICATION_NO, request.toCommand())
-        ).thenReturn(
-            GiftRecipientAddressRegistrationResult(
-                applicationNo = APPLICATION_NO,
-                status = GiftStatus.TRACKING_REGISTERED,
-                statusName = "발송 확인",
-                recipientAddressRegisteredAt = registeredAt
-            )
-        )
-
-        // When: 받는 크리에이터 인증으로 주소 등록 API를 호출한다.
-        mockMvc.perform(
-            post("/api/v2/gifts/{applicationNo}/recipient-address", APPLICATION_NO)
-                .with(user(MemberAdapter(member)))
-                .contentType(MediaType.APPLICATION_JSON)
-                .content(objectMapper.writeValueAsString(request))
-        )
-            // Then: 성공 envelope에 신청번호, 상태와 주소 등록 시각을 반환한다.
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(true))
-            .andExpect(jsonPath("$.data.applicationNo").value(APPLICATION_NO))
-            .andExpect(jsonPath("$.data.status").value("TRACKING_REGISTERED"))
-            .andExpect(jsonPath("$.data.statusName").value("발송 확인"))
-            .andExpect(jsonPath("$.data.recipientAddressRegisteredAt").value("2026-09-29T12:00:00Z"))
-    }
-
-    @Test
-    @DisplayName("받는 크리에이터는 POST delivery-complete로 수령 확인 성공 envelope를 받는다")
-    fun shouldConfirmDelivery() {
-        val member = Member(password = "password", nickname = "creator").apply { id = RECIPIENT_ID }
-        val deliveredAt = LocalDateTime.of(2026, 9, 29, 12, 0)
-        Mockito.`when`(commandService.confirmDelivery(member, APPLICATION_NO)).thenReturn(
-            GiftDeliveryConfirmationResult(
-                applicationNo = APPLICATION_NO,
-                status = GiftStatus.DELIVERED,
-                statusName = "전달완료",
-                deliveredAt = deliveredAt
-            )
-        )
-
-        mockMvc.perform(
-            post("/api/v2/gifts/{applicationNo}/delivery-complete", APPLICATION_NO)
-                .with(user(MemberAdapter(member)))
-        )
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(true))
-            .andExpect(jsonPath("$.data.applicationNo").value(APPLICATION_NO))
-            .andExpect(jsonPath("$.data.status").value("DELIVERED"))
-            .andExpect(jsonPath("$.data.statusName").value("전달완료"))
-            .andExpect(jsonPath("$.data.deliveredAt").value("2026-09-29T12:00:00Z"))
-
-        Mockito.verify(commandService).confirmDelivery(member, APPLICATION_NO)
-    }
-
-    @Test
-    @DisplayName("팬은 POST review로 리뷰를 작성하고 keywords 배열 응답을 받는다")
-    fun shouldWriteReview() {
-        val member = Member(password = "password", nickname = "fan").apply { id = SENDER_ID }
-        val request = GiftReviewRequest(
-            rating = 5,
-            keywords = listOf("배송이 빨라요", "안내가 친절해요"),
-            comment = "선물 전달 과정이 만족스러웠습니다."
-        )
-        val createdAt = LocalDateTime.of(2026, 10, 11, 12, 0)
-        Mockito.`when`(commandService.writeReview(member, APPLICATION_NO, request.toCommand())).thenReturn(
-            GiftReviewResult(
-                reviewId = 1L,
-                applicationNo = APPLICATION_NO,
-                rating = 5,
-                keywords = listOf("배송이 빨라요", "안내가 친절해요"),
-                comment = "선물 전달 과정이 만족스러웠습니다.",
-                createdAt = createdAt
-            )
-        )
-
-        mockMvc.perform(
-            post("/api/v2/gifts/{applicationNo}/review", APPLICATION_NO)
-                .with(user(MemberAdapter(member)))
-                .contentType(MediaType.APPLICATION_JSON)
-                .content(objectMapper.writeValueAsString(request))
-        )
-            .andExpect(status().isOk)
-            .andExpect(jsonPath("$.success").value(true))
-            .andExpect(jsonPath("$.data.reviewId").value(1L))
-            .andExpect(jsonPath("$.data.applicationNo").value(APPLICATION_NO))
-            .andExpect(jsonPath("$.data.rating").value(5))
-            .andExpect(jsonPath("$.data.keywords[0]").value("배송이 빨라요"))
-            .andExpect(jsonPath("$.data.keywords[1]").value("안내가 친절해요"))
-            .andExpect(jsonPath("$.data.keyword").doesNotExist())
-            .andExpect(jsonPath("$.data.comment").value("선물 전달 과정이 만족스러웠습니다."))
-            .andExpect(jsonPath("$.data.createdAt").value("2026-10-11T12:00:00Z"))
-
-        Mockito.verify(commandService).writeReview(member, APPLICATION_NO, request.toCommand())
-    }
-
-    private fun saveGift(
-        applicationNo: String,
-        senderMemberId: Long,
-        recipientMemberId: Long,
-        status: GiftStatus
-    ) = giftRepository.save(
-        Gift(
-            applicationNo = applicationNo,
-            senderMemberId = senderMemberId,
-            recipientMemberId = recipientMemberId,
-            status = status,
-            sizeCode = GiftSize.SMALL,
-            categoryId = CATEGORY_ID,
-            categoryNameSnapshot = "인형",
-            salePriceCan = 80,
-            canUsageId = 1L,
-            senderTermsAgreed = true,
-            senderPrivacyAgreed = true,
-            senderTermsAgreedAt = LocalDateTime.of(2026, 9, 29, 12, 0),
-            senderPrivacyAgreedAt = LocalDateTime.of(2026, 9, 29, 12, 0)
-        )
-    )
-
-    private fun giftCategory(
-        classificationNumber: String,
-        categoryCode: String,
-        receiptCode: String,
-        name: String,
-        representativeItem: String,
-        requiresDamageWaiver: Boolean,
-        isActive: Boolean
-    ) = GiftCategory(
-        classificationNumber = classificationNumber,
-        categoryCode = categoryCode,
-        name = name,
-        receiptCode = receiptCode,
-        representativeItem = representativeItem,
-        requiresDamageWaiver = requiresDamageWaiver,
-        isActive = isActive
-    )
-
-    private companion object {
-        const val SENDER_ID = 1L
-        const val RECIPIENT_ID = 2L
-        const val CATEGORY_ID = 3L
-        const val APPLICATION_NO = "G20260929000001"
-    }
-}
@@ -1,876 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift
-
-import kr.co.vividnext.sodalive.can.CanRepository
-import kr.co.vividnext.sodalive.can.charge.Charge
-import kr.co.vividnext.sodalive.can.charge.ChargeRepository
-import kr.co.vividnext.sodalive.can.payment.CanPaymentService
-import kr.co.vividnext.sodalive.can.payment.Payment
-import kr.co.vividnext.sodalive.can.payment.PaymentGateway
-import kr.co.vividnext.sodalive.can.payment.PaymentStatus
-import kr.co.vividnext.sodalive.can.use.CanUsage
-import kr.co.vividnext.sodalive.can.use.UseCan
-import kr.co.vividnext.sodalive.can.use.UseCanCalculate
-import kr.co.vividnext.sodalive.can.use.UseCanCalculateRepository
-import kr.co.vividnext.sodalive.can.use.UseCanRepository
-import kr.co.vividnext.sodalive.common.CountryContext
-import kr.co.vividnext.sodalive.common.SodaException
-import kr.co.vividnext.sodalive.i18n.LangContext
-import kr.co.vividnext.sodalive.i18n.SodaMessageSource
-import kr.co.vividnext.sodalive.member.Member
-import kr.co.vividnext.sodalive.member.MemberRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.Gift
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategory
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategoryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDelivery
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDeliveryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftReview
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftReviewRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftSizePrice
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftSizePriceRepository
-import kr.co.vividnext.sodalive.v2.gift.application.GiftApplicationCommand
-import kr.co.vividnext.sodalive.v2.gift.application.GiftApplicationNoGenerator
-import kr.co.vividnext.sodalive.v2.gift.application.GiftCancellationResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftCommandService
-import kr.co.vividnext.sodalive.v2.gift.application.GiftDeliveryConfirmationResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftPushService
-import kr.co.vividnext.sodalive.v2.gift.application.GiftRecipientAddressRegistrationCommand
-import kr.co.vividnext.sodalive.v2.gift.application.GiftRecipientAddressRegistrationResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftReviewCommand
-import kr.co.vividnext.sodalive.v2.gift.application.GiftReviewResult
-import kr.co.vividnext.sodalive.v2.gift.application.GiftTrackingRegistrationCommand
-import kr.co.vividnext.sodalive.v2.gift.application.GiftTrackingRegistrationResult
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftSize
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Assertions.assertThrows
-import org.junit.jupiter.api.DisplayName
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.MethodSource
-import org.mockito.Mockito
-import java.time.LocalDateTime
-import java.util.Optional
-
-class GiftCommandServiceTest {
-    @Test
-    @DisplayName("선물 캔 사용은 한 번만 환불할 수 있다")
-    fun shouldSpendAndRefundGiftCanOnlyOnce() {
-        // Given: 충전 캔을 보유한 선물 발신자와 결제 서비스를 준비한다.
-        val member = Member(password = "password", nickname = "sender")
-        member.id = MEMBER_ID
-        member.pgChargeCan = INITIAL_CAN
-        val charge = Charge(chargeCan = INITIAL_CAN, rewardCan = 0)
-        charge.id = CHARGE_ID
-        charge.member = member
-        charge.payment = Payment(status = PaymentStatus.COMPLETE, paymentGateway = PaymentGateway.PG)
-        val fixture = CanPaymentFixture(member, charge)
-
-        // When: 선물용 캔을 사용한 뒤 해당 사용 내역을 환불한다.
-        val useCanId = fixture.service.spendGiftCan(
-            memberId = MEMBER_ID,
-            needCan = GIFT_PRICE_CAN,
-            container = "web"
-        )
-        val afterSpendCan = member.getChargeCan("web") + member.getRewardCan("web")
-        fixture.service.refundGiftCan(memberId = MEMBER_ID, useCanId = useCanId)
-        val afterRefundCan = member.getChargeCan("web") + member.getRewardCan("web")
-
-        // Then: 발신자와 GIFT 용도가 저장되고, 잔액이 복원되며 재환불은 거부된다.
-        assertEquals(CanUsage.GIFT, fixture.savedUseCan.canUsage)
-        assertEquals(member, fixture.savedUseCan.member)
-        assertEquals(INITIAL_CAN - GIFT_PRICE_CAN, afterSpendCan)
-        assertEquals(INITIAL_CAN, afterRefundCan)
-        assertEquals(true, fixture.savedUseCan.isRefund)
-        assertThrows(SodaException::class.java) {
-            fixture.service.refundGiftCan(memberId = MEMBER_ID, useCanId = useCanId)
-        }
-    }
-
-    @Test
-    @DisplayName("선물 신청은 가격과 약관 동의, 배송 기한을 스냅샷으로 저장하고 캔을 차감한다")
-    fun shouldRegisterGiftWithPriceAgreementAndDeliverySnapshots() {
-        // Given: 활성 선물 카테고리와 가격, 발신자 및 수신 크리에이터를 준비한다.
-        val fixture = GiftApplicationFixture()
-
-        // When: 팬이 선물을 신청한다.
-        val result = fixture.service.registerGift(fixture.sender, validGiftApplicationCommand())
-
-        // Then: 신청 정보와 배송 기한을 저장하고 판매가만큼 캔을 차감한다.
-        assertEquals(APPLICATION_NO, result.applicationNo)
-        assertEquals(GiftStatus.RECEIVED, result.status)
-        assertEquals(GiftStatus.RECEIVED.displayName, result.statusName)
-        assertEquals(SALE_PRICE_CAN, result.priceCan)
-        assertEquals(NOW.plusDays(3), result.trackingDeadlineAt)
-        assertEquals(SENDER_ID, fixture.savedGift.senderMemberId)
-        assertEquals(RECIPIENT_ID, fixture.savedGift.recipientMemberId)
-        assertEquals(GiftStatus.RECEIVED, fixture.savedGift.status)
-        assertEquals(GiftSize.SMALL, fixture.savedGift.sizeCode)
-        assertEquals(CATEGORY_ID, fixture.savedGift.categoryId)
-        assertEquals("인형", fixture.savedGift.categoryNameSnapshot)
-        assertEquals(SALE_PRICE_CAN, fixture.savedGift.salePriceCan)
-        assertEquals(USE_CAN_ID, fixture.savedGift.canUsageId)
-        assertEquals(true, fixture.savedGift.senderTermsAgreed)
-        assertEquals(true, fixture.savedGift.senderPrivacyAgreed)
-        assertEquals(NOW, fixture.savedGift.senderTermsAgreedAt)
-        assertEquals(NOW, fixture.savedGift.senderPrivacyAgreedAt)
-        assertEquals(true, fixture.savedGift.damageWaiverAgreed)
-        assertEquals(GIFT_ID, fixture.savedDelivery.giftId)
-        assertEquals("홍길동", fixture.savedDelivery.senderName)
-        assertEquals("01012345678", fixture.savedDelivery.senderPhoneNumber)
-        assertEquals("06234", fixture.savedDelivery.senderZipCode)
-        assertEquals("서울시 강남구", fixture.savedDelivery.senderAddress)
-        assertEquals("101동 1001호", fixture.savedDelivery.senderAddressDetail)
-        assertEquals(NOW.plusDays(3), fixture.savedDelivery.trackingDeadlineAt)
-        Mockito.verify(fixture.canPaymentService).spendGiftCan(SENDER_ID, SALE_PRICE_CAN, "aos")
-    }
-
-    @Test
-    @DisplayName("보낸 팬은 운송장 등록 전 선물을 취소하고 전액 환불받는다")
-    fun shouldCancelReceivedGiftAndRefundOnce() {
-        // Given: 접수 상태의 선물과 발신자 배송 정보를 준비한다.
-        val fixture = GiftApplicationFixture()
-        fixture.prepareGiftForCancellation()
-
-        // When: 보낸 팬이 선물을 취소한다.
-        val result = fixture.service.cancelGift(fixture.sender, APPLICATION_NO)
-
-        // Then: 선물과 배송 정보에 취소 시각을 저장하고 한 번만 환불한다.
-        assertEquals(
-            GiftCancellationResult(
-                applicationNo = APPLICATION_NO,
-                status = GiftStatus.CANCELED,
-                statusName = GiftStatus.CANCELED.displayName,
-                priceCan = SALE_PRICE_CAN,
-                canceledAt = NOW
-            ),
-            result
-        )
-        assertEquals(GiftStatus.CANCELED, fixture.cancellationGift.status)
-        assertEquals(NOW, fixture.cancellationDelivery.canceledAt)
-        Mockito.verify(fixture.canPaymentService).refundGiftCan(SENDER_ID, USE_CAN_ID)
-    }
-
-    @Test
-    @DisplayName("보낸 팬은 접수된 선물의 운송장을 등록하고 크리에이터 배송지 입력 기한을 생성한다")
-    fun shouldRegisterTrackingForReceivedGift() {
-        // Given: 접수 상태의 선물과 발신자 배송 정보를 준비한다.
-        val fixture = GiftApplicationFixture()
-        fixture.prepareGiftForTracking()
-
-        // When: 보낸 팬이 택배사와 운송장 번호를 등록한다.
-        val result = fixture.service.registerTracking(
-            fixture.sender,
-            APPLICATION_NO,
-            validGiftTrackingRegistrationCommand()
-        )
-
-        // Then: 발송 확인 상태와 운송장 정보, 수신자 주소 입력 기한을 저장한다.
-        assertEquals(
-            GiftTrackingRegistrationResult(
-                applicationNo = APPLICATION_NO,
-                status = GiftStatus.TRACKING_REGISTERED,
-                statusName = GiftStatus.TRACKING_REGISTERED.displayName,
-                courierCompanyName = "CJ대한통운",
-                trackingNumber = "1234567890",
-                trackingRegisteredAt = NOW,
-                recipientAddressDeadlineAt = NOW.plusDays(7)
-            ),
-            result
-        )
-        assertEquals(GiftStatus.TRACKING_REGISTERED, fixture.trackingGift.status)
-        assertEquals("CJ대한통운", fixture.trackingDelivery.courierCompanyName)
-        assertEquals("1234567890", fixture.trackingDelivery.trackingNumber)
-        assertEquals(NOW, fixture.trackingDelivery.trackingRegisteredAt)
-        assertEquals(NOW.plusDays(7), fixture.trackingDelivery.recipientAddressDeadlineAt)
-        Mockito.verify(fixture.giftPushService).sendTrackingRegisteredToRecipient(APPLICATION_NO, RECIPIENT_ID)
-    }
-
-    @ParameterizedTest
-    @MethodSource("recipientAddressRegistrableStatuses")
-    @DisplayName("받는 크리에이터는 운송장 등록 이후 종료 전 상태에서 주소와 수령 동의를 등록한다")
-    fun shouldRegisterRecipientAddressAndAgreements(status: GiftStatus) {
-        // Given: 주소 입력이 허용된 선물과 받는 크리에이터를 준비한다.
-        val fixture = GiftApplicationFixture()
-        fixture.prepareGiftForRecipientAddress(status = status)
-
-        // When: 받는 크리에이터가 배송지와 수령 약관 동의를 등록한다.
-        val result = fixture.service.registerRecipientAddress(
-            fixture.creator,
-            APPLICATION_NO,
-            validGiftRecipientAddressRegistrationCommand()
-        )
-
-        // Then: 주소 스냅샷과 두 동의 시각을 저장하고 현재 상태를 반환한다.
-        assertEquals(
-            GiftRecipientAddressRegistrationResult(
-                applicationNo = APPLICATION_NO,
-                status = status,
-                statusName = status.displayName,
-                recipientAddressRegisteredAt = NOW
-            ),
-            result
-        )
-        assertEquals("김소다", fixture.recipientAddressDelivery.recipientName)
-        assertEquals("01098765432", fixture.recipientAddressDelivery.recipientPhoneNumber)
-        assertEquals("04524", fixture.recipientAddressDelivery.recipientZipCode)
-        assertEquals("서울시 중구", fixture.recipientAddressDelivery.recipientAddress)
-        assertEquals("202호", fixture.recipientAddressDelivery.recipientAddressDetail)
-        assertEquals(true, fixture.recipientAddressGift.recipientTermsAgreed)
-        assertEquals(true, fixture.recipientAddressGift.recipientPrivacyAgreed)
-        assertEquals(NOW, fixture.recipientAddressGift.recipientTermsAgreedAt)
-        assertEquals(NOW, fixture.recipientAddressGift.recipientPrivacyAgreedAt)
-    }
-
-    @Test
-    @DisplayName("받는 크리에이터는 검수 완료 선물의 수령을 확인하고 전달 완료 시각을 저장한다")
-    fun shouldConfirmDeliveryForInspectionCompletedGift() {
-        val fixture = GiftApplicationFixture()
-        fixture.prepareGiftForDeliveryConfirmation()
-
-        val result = fixture.service.confirmDelivery(fixture.creator, APPLICATION_NO)
-
-        assertEquals(
-            GiftDeliveryConfirmationResult(
-                applicationNo = APPLICATION_NO,
-                status = GiftStatus.DELIVERED,
-                statusName = GiftStatus.DELIVERED.displayName,
-                deliveredAt = NOW
-            ),
-            result
-        )
-        assertEquals(GiftStatus.DELIVERED, fixture.deliveryConfirmationGift.status)
-        assertEquals(NOW, fixture.deliveryConfirmationDelivery.deliveredAt)
-        Mockito.verifyNoInteractions(fixture.giftPushService)
-    }
-
-    @Test
-    @DisplayName("보낸 팬은 전달 완료 선물에 리뷰를 한 번 작성한다")
-    fun shouldWriteReviewForDeliveredGiftBySender() {
-        val fixture = GiftApplicationFixture()
-        fixture.prepareGiftForReview()
-
-        val result = fixture.service.writeReview(fixture.sender, APPLICATION_NO, validGiftReviewCommand())
-
-        assertEquals(
-            GiftReviewResult(
-                reviewId = REVIEW_ID,
-                applicationNo = APPLICATION_NO,
-                rating = 5,
-                keywords = listOf("배송이 빨라요", "안내가 친절해요"),
-                comment = "선물 전달 과정이 만족스러웠습니다.",
-                createdAt = NOW
-            ),
-            result
-        )
-        assertEquals(GIFT_ID, fixture.savedReview.giftId)
-        assertEquals(SENDER_ID, fixture.savedReview.senderMemberId)
-        assertEquals(5, fixture.savedReview.rating)
-        assertEquals("배송이 빨라요,안내가 친절해요", fixture.savedReview.keywords)
-        assertEquals("선물 전달 과정이 만족스러웠습니다.", fixture.savedReview.comment)
-    }
-
-    @ParameterizedTest
-    @MethodSource("invalidGiftReviewScenarios")
-    @DisplayName("리뷰 작성은 보낸 팬의 전달 완료 선물, 1회, 유효한 별점과 내용만 허용한다")
-    fun shouldRejectInvalidGiftReview(scenario: InvalidGiftReviewScenario) {
-        val fixture = GiftApplicationFixture()
-        fixture.prepareGiftForReview(
-            status = scenario.status,
-            senderMemberId = scenario.senderMemberId,
-            reviewExists = scenario.reviewExists
-        )
-        val requester = Member(password = "password", nickname = "requester").apply { id = scenario.requesterMemberId }
-
-        val exception = assertThrows(SodaException::class.java) {
-            fixture.service.writeReview(requester, APPLICATION_NO, scenario.command)
-        }
-
-        assertEquals("common.error.invalid_request", exception.messageKey)
-        Mockito.verify(fixture.reviewRepository, Mockito.never()).save(Mockito.any(GiftReview::class.java))
-    }
-
-    @ParameterizedTest
-    @MethodSource("invalidGiftDeliveryConfirmationScenarios")
-    @DisplayName("수령 확인은 받는 크리에이터의 검수 완료 선물에만 가능하고 배송 정보가 필요하다")
-    fun shouldRejectInvalidGiftDeliveryConfirmation(scenario: InvalidGiftDeliveryConfirmationScenario) {
-        val fixture = GiftApplicationFixture()
-        fixture.prepareGiftForDeliveryConfirmation(
-            status = scenario.status,
-            recipientMemberId = scenario.recipientMemberId,
-            deliveryExists = scenario.deliveryExists
-        )
-        val requester = Member(password = "password", nickname = "requester").apply { id = scenario.requesterMemberId }
-
-        val exception = assertThrows(SodaException::class.java) {
-            fixture.service.confirmDelivery(requester, APPLICATION_NO)
-        }
-
-        assertEquals("common.error.invalid_request", exception.messageKey)
-        assertEquals(scenario.status, fixture.deliveryConfirmationGift.status)
-        assertEquals(null, fixture.deliveryConfirmationDelivery.deliveredAt)
-    }
-
-    @ParameterizedTest
-    @MethodSource("invalidGiftRecipientAddressRegistrationScenarios")
-    @DisplayName("수령자 주소 등록은 받는 크리에이터, 허용 상태, 필수 주소와 두 동의가 필요하다")
-    fun shouldRejectInvalidGiftRecipientAddressRegistration(scenario: InvalidGiftRecipientAddressRegistrationScenario) {
-        // Given: 권한, 상태 또는 입력값이 유효하지 않은 선물을 준비한다.
-        val fixture = GiftApplicationFixture()
-        fixture.prepareGiftForRecipientAddress(
-            status = scenario.status,
-            recipientMemberId = scenario.recipientMemberId,
-            deliveryExists = scenario.deliveryExists
-        )
-        val requester = Member(password = "password", nickname = "requester").apply { id = scenario.requesterMemberId }
-
-        // When: 배송지 등록을 요청한다.
-        val exception = assertThrows(SodaException::class.java) {
-            fixture.service.registerRecipientAddress(requester, APPLICATION_NO, scenario.command)
-        }
-
-        // Then: 공통 요청 오류를 반환하고 선물 상태와 수령 동의를 바꾸지 않는다.
-        assertEquals("common.error.invalid_request", exception.messageKey)
-        assertEquals(scenario.status, fixture.recipientAddressGift.status)
-        assertEquals(false, fixture.recipientAddressGift.recipientTermsAgreed)
-        assertEquals(false, fixture.recipientAddressGift.recipientPrivacyAgreed)
-    }
-
-    @ParameterizedTest
-    @MethodSource("invalidGiftTrackingRegistrationScenarios")
-    @DisplayName("운송장 등록은 보낸 팬의 접수 상태에서 유효한 택배사와 운송장 번호가 있어야 한다")
-    fun shouldRejectInvalidGiftTrackingRegistration(scenario: InvalidGiftTrackingRegistrationScenario) {
-        // Given: 운송장 등록 권한, 상태, 입력값 또는 배송 정보가 유효하지 않은 선물을 준비한다.
-        val fixture = GiftApplicationFixture()
-        fixture.prepareGiftForTracking(scenario.status, scenario.senderMemberId, scenario.deliveryExists)
-        val requester = Member(password = "password", nickname = "requester").apply { id = scenario.requesterMemberId }
-
-        // When: 운송장 등록을 요청한다.
-        val exception = assertThrows(SodaException::class.java) {
-            fixture.service.registerTracking(requester, APPLICATION_NO, scenario.command)
-        }
-
-        // Then: 공통 요청 오류를 반환하고 선물 상태를 바꾸지 않는다.
-        assertEquals("common.error.invalid_request", exception.messageKey)
-        assertEquals(scenario.status, fixture.trackingGift.status)
-    }
-
-    @ParameterizedTest
-    @MethodSource("invalidGiftCancellationScenarios")
-    @DisplayName("선물 취소는 보낸 팬의 접수 상태에서만 가능하다")
-    fun shouldRejectGiftCancellationForInvalidSenderOrStatus(scenario: InvalidGiftCancellationScenario) {
-        // Given: 취소 권한 또는 상태가 유효하지 않은 선물을 준비한다.
-        val fixture = GiftApplicationFixture()
-        fixture.prepareGiftForCancellation(scenario.status, scenario.senderMemberId)
-        val requester = Member(password = "password", nickname = "requester").apply { id = scenario.requesterMemberId }
-
-        // When: 취소를 요청한다.
-        val exception = assertThrows(SodaException::class.java) {
-            fixture.service.cancelGift(requester, APPLICATION_NO)
-        }
-
-        // Then: 환불하지 않고 공통 요청 오류를 반환한다.
-        assertEquals("common.error.invalid_request", exception.messageKey)
-        Mockito.verify(fixture.canPaymentService, Mockito.never()).refundGiftCan(
-            Mockito.anyLong(),
-            Mockito.anyLong()
-        )
-    }
-
-    @ParameterizedTest
-    @MethodSource("invalidGiftApplicationScenarios")
-    @DisplayName("선물 신청은 필수 발신자 정보, 동의, 활성 옵션 및 수신 크리에이터를 검증한다")
-    fun shouldRejectInvalidGiftApplication(scenario: InvalidGiftApplicationScenario) {
-        // Given: 하나의 신청 조건만 유효하지 않은 선물 신청을 준비한다.
-        val fixture = GiftApplicationFixture()
-        fixture.category.isActive = scenario.categoryActive
-        fixture.category.requiresDamageWaiver = scenario.requiresDamageWaiver
-        fixture.sizePrice.isActive = scenario.sizePriceActive
-        fixture.setCreatorExists(scenario.creatorExists)
-
-        // When: 유효하지 않은 신청을 등록한다.
-        val exception = assertThrows(SodaException::class.java) {
-            fixture.service.registerGift(fixture.sender, scenario.command)
-        }
-
-        // Then: 캔을 차감하지 않고 공통 요청 오류를 반환한다.
-        assertEquals("common.error.invalid_request", exception.messageKey)
-        Mockito.verifyNoInteractions(fixture.canPaymentService)
-    }
-
-    private class CanPaymentFixture(member: Member, charge: Charge) {
-        private val canRepository = Mockito.mock(CanRepository::class.java)
-        private val memberRepository = Mockito.mock(MemberRepository::class.java)
-        private val chargeRepository = Mockito.mock(ChargeRepository::class.java)
-        private val useCanRepository = Mockito.mock(UseCanRepository::class.java)
-        private val useCanCalculateRepository = Mockito.mock(UseCanCalculateRepository::class.java)
-        private val useCanCalculates = mutableListOf<UseCanCalculate>()
-        lateinit var savedUseCan: UseCan
-            private set
-
-        val service = CanPaymentService(
-            repository = canRepository,
-            memberRepository = memberRepository,
-            chargeRepository = chargeRepository,
-            useCanRepository = useCanRepository,
-            useCanCalculateRepository = useCanCalculateRepository,
-            messageSource = SodaMessageSource(),
-            langContext = LangContext(),
-            countryContext = CountryContext()
-        )
-
-        init {
-            Mockito.`when`(memberRepository.findById(MEMBER_ID)).thenReturn(Optional.of(member))
-            Mockito.`when`(
-                chargeRepository.getOldestChargeWhereRewardCanGreaterThan0(0L, MEMBER_ID, "web")
-            ).thenReturn(null)
-            Mockito.`when`(
-                chargeRepository.getOldestChargeWhereChargeCanGreaterThan0(0L, MEMBER_ID, "web")
-            ).thenReturn(charge)
-            Mockito.`when`(useCanRepository.save(Mockito.any(UseCan::class.java))).thenAnswer { invocation ->
-                invocation.getArgument<UseCan>(0).apply {
-                    id = USE_CAN_ID
-                    savedUseCan = this
-                }
-            }
-            Mockito.`when`(useCanRepository.findById(USE_CAN_ID)).thenAnswer { Optional.of(savedUseCan) }
-            Mockito.`when`(useCanCalculateRepository.save(Mockito.any(UseCanCalculate::class.java))).thenAnswer {
-                    invocation ->
-                invocation.getArgument<UseCanCalculate>(0).also(useCanCalculates::add)
-            }
-            Mockito.`when`(useCanCalculateRepository.findByUseCanIdAndStatus(USE_CAN_ID)).thenReturn(useCanCalculates)
-        }
-    }
-
-    private class GiftApplicationFixture {
-        val giftRepository = Mockito.mock(GiftRepository::class.java)
-        val deliveryRepository = Mockito.mock(GiftDeliveryRepository::class.java)
-        val reviewRepository = Mockito.mock(GiftReviewRepository::class.java)
-        val categoryRepository = Mockito.mock(GiftCategoryRepository::class.java)
-        val sizePriceRepository = Mockito.mock(GiftSizePriceRepository::class.java)
-        val memberRepository = Mockito.mock(MemberRepository::class.java)
-        val applicationNoGenerator = Mockito.mock(GiftApplicationNoGenerator::class.java)
-        val canPaymentService = Mockito.mock(CanPaymentService::class.java)
-        val giftPushService = Mockito.mock(GiftPushService::class.java)
-        val sender = Member(password = "password", nickname = "sender", container = "aos").apply { id = SENDER_ID }
-        val creator = Member(password = "password", nickname = "creator").apply { id = RECIPIENT_ID }
-        val category = GiftCategory(
-            classificationNumber = "100",
-            categoryCode = "DOLL",
-            name = "인형",
-            receiptCode = "A",
-            representativeItem = "피규어",
-            requiresDamageWaiver = false,
-            isActive = true
-        ).apply { id = CATEGORY_ID }
-        val sizePrice = GiftSizePrice(GiftSize.SMALL, BASE_PRICE_CAN, SALE_PRICE_CAN, true)
-        lateinit var savedGift: Gift
-        lateinit var savedDelivery: GiftDelivery
-        lateinit var cancellationGift: Gift
-        lateinit var cancellationDelivery: GiftDelivery
-        lateinit var trackingGift: Gift
-        lateinit var trackingDelivery: GiftDelivery
-        lateinit var recipientAddressGift: Gift
-        lateinit var recipientAddressDelivery: GiftDelivery
-        lateinit var deliveryConfirmationGift: Gift
-        lateinit var deliveryConfirmationDelivery: GiftDelivery
-        lateinit var reviewGift: Gift
-        lateinit var savedReview: GiftReview
-
-        val service = GiftCommandService(
-            giftRepository = giftRepository,
-            deliveryRepository = deliveryRepository,
-            reviewRepository = reviewRepository,
-            categoryRepository = categoryRepository,
-            sizePriceRepository = sizePriceRepository,
-            memberRepository = memberRepository,
-            applicationNoGenerator = applicationNoGenerator,
-            canPaymentService = canPaymentService,
-            giftPushService = giftPushService,
-            now = { NOW }
-        )
-
-        init {
-            setCreatorExists(true)
-            Mockito.`when`(categoryRepository.findById(CATEGORY_ID)).thenReturn(Optional.of(category))
-            Mockito.`when`(sizePriceRepository.findBySizeCode(GiftSize.SMALL)).thenReturn(sizePrice)
-            Mockito.`when`(applicationNoGenerator.generate(category, NOW)).thenReturn(APPLICATION_NO)
-            Mockito.`when`(canPaymentService.spendGiftCan(SENDER_ID, SALE_PRICE_CAN, "aos")).thenReturn(USE_CAN_ID)
-            Mockito.`when`(giftRepository.save(Mockito.any(Gift::class.java))).thenAnswer { invocation ->
-                invocation.getArgument<Gift>(0).apply {
-                    id = GIFT_ID
-                    savedGift = this
-                }
-            }
-            Mockito.`when`(deliveryRepository.save(Mockito.any(GiftDelivery::class.java))).thenAnswer { invocation ->
-                invocation.getArgument<GiftDelivery>(0).also { savedDelivery = it }
-            }
-            Mockito.`when`(reviewRepository.save(Mockito.any(GiftReview::class.java))).thenAnswer { invocation ->
-                invocation.getArgument<GiftReview>(0).apply {
-                    id = REVIEW_ID
-                    createdAt = NOW
-                    savedReview = this
-                }
-            }
-        }
-
-        fun setCreatorExists(exists: Boolean) {
-            Mockito.`when`(memberRepository.findCreatorByIdOrNull(RECIPIENT_ID)).thenReturn(creator.takeIf { exists })
-        }
-
-        fun prepareGiftForCancellation(
-            status: GiftStatus = GiftStatus.RECEIVED,
-            senderMemberId: Long = SENDER_ID
-        ) {
-            cancellationGift = Gift(
-                applicationNo = APPLICATION_NO,
-                senderMemberId = senderMemberId,
-                recipientMemberId = RECIPIENT_ID,
-                status = status,
-                sizeCode = GiftSize.SMALL,
-                categoryId = CATEGORY_ID,
-                categoryNameSnapshot = "인형",
-                salePriceCan = SALE_PRICE_CAN,
-                canUsageId = USE_CAN_ID,
-                senderTermsAgreed = true,
-                senderPrivacyAgreed = true,
-                senderTermsAgreedAt = NOW,
-                senderPrivacyAgreedAt = NOW,
-                damageWaiverAgreed = true
-            ).apply { id = GIFT_ID }
-            cancellationDelivery = GiftDelivery(
-                giftId = GIFT_ID,
-                senderName = "홍길동",
-                senderPhoneNumber = "01012345678",
-                senderZipCode = "06234",
-                senderAddress = "서울시 강남구",
-                trackingDeadlineAt = NOW.plusDays(3)
-            )
-            Mockito.`when`(giftRepository.findByApplicationNo(APPLICATION_NO)).thenReturn(cancellationGift)
-            Mockito.`when`(deliveryRepository.findByGiftId(GIFT_ID)).thenReturn(cancellationDelivery)
-        }
-
-        fun prepareGiftForTracking(
-            status: GiftStatus = GiftStatus.RECEIVED,
-            senderMemberId: Long = SENDER_ID,
-            deliveryExists: Boolean = true
-        ) {
-            trackingGift = Gift(
-                applicationNo = APPLICATION_NO,
-                senderMemberId = senderMemberId,
-                recipientMemberId = RECIPIENT_ID,
-                status = status,
-                sizeCode = GiftSize.SMALL,
-                categoryId = CATEGORY_ID,
-                categoryNameSnapshot = "인형",
-                salePriceCan = SALE_PRICE_CAN,
-                canUsageId = USE_CAN_ID,
-                senderTermsAgreed = true,
-                senderPrivacyAgreed = true,
-                senderTermsAgreedAt = NOW,
-                senderPrivacyAgreedAt = NOW,
-                damageWaiverAgreed = true
-            ).apply { id = GIFT_ID }
-            trackingDelivery = GiftDelivery(
-                giftId = GIFT_ID,
-                senderName = "홍길동",
-                senderPhoneNumber = "01012345678",
-                senderZipCode = "06234",
-                senderAddress = "서울시 강남구",
-                trackingDeadlineAt = NOW.plusDays(3)
-            )
-            Mockito.`when`(giftRepository.findByApplicationNo(APPLICATION_NO)).thenReturn(trackingGift)
-            Mockito.`when`(deliveryRepository.findByGiftId(GIFT_ID)).thenReturn(
-                trackingDelivery.takeIf { deliveryExists }
-            )
-        }
-
-        fun prepareGiftForRecipientAddress(
-            status: GiftStatus = GiftStatus.TRACKING_REGISTERED,
-            recipientMemberId: Long = RECIPIENT_ID,
-            deliveryExists: Boolean = true
-        ) {
-            recipientAddressGift = Gift(
-                applicationNo = APPLICATION_NO,
-                senderMemberId = SENDER_ID,
-                recipientMemberId = recipientMemberId,
-                status = status,
-                sizeCode = GiftSize.SMALL,
-                categoryId = CATEGORY_ID,
-                categoryNameSnapshot = "인형",
-                salePriceCan = SALE_PRICE_CAN,
-                canUsageId = USE_CAN_ID,
-                senderTermsAgreed = true,
-                senderPrivacyAgreed = true,
-                senderTermsAgreedAt = NOW,
-                senderPrivacyAgreedAt = NOW,
-                damageWaiverAgreed = true
-            ).apply { id = GIFT_ID }
-            recipientAddressDelivery = GiftDelivery(
-                giftId = GIFT_ID,
-                senderName = "홍길동",
-                senderPhoneNumber = "01012345678",
-                senderZipCode = "06234",
-                senderAddress = "서울시 강남구",
-                trackingDeadlineAt = NOW.plusDays(3)
-            )
-            Mockito.`when`(giftRepository.findByApplicationNo(APPLICATION_NO)).thenReturn(recipientAddressGift)
-            Mockito.`when`(deliveryRepository.findByGiftId(GIFT_ID)).thenReturn(
-                recipientAddressDelivery.takeIf { deliveryExists }
-            )
-        }
-
-        fun prepareGiftForDeliveryConfirmation(
-            status: GiftStatus = GiftStatus.INSPECTION_COMPLETED,
-            recipientMemberId: Long = RECIPIENT_ID,
-            deliveryExists: Boolean = true
-        ) {
-            deliveryConfirmationGift = Gift(
-                applicationNo = APPLICATION_NO,
-                senderMemberId = SENDER_ID,
-                recipientMemberId = recipientMemberId,
-                status = status,
-                sizeCode = GiftSize.SMALL,
-                categoryId = CATEGORY_ID,
-                categoryNameSnapshot = "인형",
-                salePriceCan = SALE_PRICE_CAN,
-                canUsageId = USE_CAN_ID,
-                senderTermsAgreed = true,
-                senderPrivacyAgreed = true,
-                senderTermsAgreedAt = NOW,
-                senderPrivacyAgreedAt = NOW,
-                damageWaiverAgreed = true
-            ).apply { id = GIFT_ID }
-            deliveryConfirmationDelivery = GiftDelivery(
-                giftId = GIFT_ID,
-                senderName = "홍길동",
-                senderPhoneNumber = "01012345678",
-                senderZipCode = "06234",
-                senderAddress = "서울시 강남구",
-                trackingDeadlineAt = NOW.plusDays(3)
-            )
-            Mockito.`when`(giftRepository.findByApplicationNo(APPLICATION_NO)).thenReturn(deliveryConfirmationGift)
-            Mockito.`when`(deliveryRepository.findByGiftId(GIFT_ID)).thenReturn(
-                deliveryConfirmationDelivery.takeIf { deliveryExists }
-            )
-        }
-
-        fun prepareGiftForReview(
-            status: GiftStatus = GiftStatus.DELIVERED,
-            senderMemberId: Long = SENDER_ID,
-            reviewExists: Boolean = false
-        ) {
-            reviewGift = Gift(
-                applicationNo = APPLICATION_NO,
-                senderMemberId = senderMemberId,
-                recipientMemberId = RECIPIENT_ID,
-                status = status,
-                sizeCode = GiftSize.SMALL,
-                categoryId = CATEGORY_ID,
-                categoryNameSnapshot = "인형",
-                salePriceCan = SALE_PRICE_CAN,
-                canUsageId = USE_CAN_ID,
-                senderTermsAgreed = true,
-                senderPrivacyAgreed = true,
-                senderTermsAgreedAt = NOW,
-                senderPrivacyAgreedAt = NOW,
-                damageWaiverAgreed = true
-            ).apply { id = GIFT_ID }
-            Mockito.`when`(giftRepository.findByApplicationNo(APPLICATION_NO)).thenReturn(reviewGift)
-            Mockito.`when`(reviewRepository.findByGiftId(GIFT_ID)).thenReturn(
-                GiftReview(GIFT_ID, SENDER_ID, 5).takeIf { reviewExists }
-            )
-        }
-    }
-
-    data class InvalidGiftApplicationScenario(
-        val command: GiftApplicationCommand,
-        val categoryActive: Boolean = true,
-        val requiresDamageWaiver: Boolean = false,
-        val sizePriceActive: Boolean = true,
-        val creatorExists: Boolean = true
-    )
-
-    data class InvalidGiftCancellationScenario(
-        val requesterMemberId: Long,
-        val senderMemberId: Long,
-        val status: GiftStatus
-    )
-
-    data class InvalidGiftTrackingRegistrationScenario(
-        val requesterMemberId: Long = SENDER_ID,
-        val senderMemberId: Long = SENDER_ID,
-        val status: GiftStatus = GiftStatus.RECEIVED,
-        val command: GiftTrackingRegistrationCommand = validGiftTrackingRegistrationCommand(),
-        val deliveryExists: Boolean = true
-    )
-
-    data class InvalidGiftRecipientAddressRegistrationScenario(
-        val requesterMemberId: Long = RECIPIENT_ID,
-        val recipientMemberId: Long = RECIPIENT_ID,
-        val status: GiftStatus = GiftStatus.TRACKING_REGISTERED,
-        val command: GiftRecipientAddressRegistrationCommand = validGiftRecipientAddressRegistrationCommand(),
-        val deliveryExists: Boolean = true
-    )
-
-    data class InvalidGiftDeliveryConfirmationScenario(
-        val requesterMemberId: Long = RECIPIENT_ID,
-        val recipientMemberId: Long = RECIPIENT_ID,
-        val status: GiftStatus = GiftStatus.INSPECTION_COMPLETED,
-        val deliveryExists: Boolean = true
-    )
-
-    data class InvalidGiftReviewScenario(
-        val requesterMemberId: Long = SENDER_ID,
-        val senderMemberId: Long = SENDER_ID,
-        val status: GiftStatus = GiftStatus.DELIVERED,
-        val command: GiftReviewCommand = validGiftReviewCommand(),
-        val reviewExists: Boolean = false
-    )
-
-    private companion object {
-        const val MEMBER_ID = 1L
-        const val CHARGE_ID = 10L
-        const val USE_CAN_ID = 100L
-        const val INITIAL_CAN = 100
-        const val GIFT_PRICE_CAN = 30
-        const val SENDER_ID = 2L
-        const val OTHER_MEMBER_ID = 4L
-        const val RECIPIENT_ID = 3L
-        const val CATEGORY_ID = 4L
-        const val GIFT_ID = 5L
-        const val REVIEW_ID = 6L
-        const val APPLICATION_NO = "G20260929000001"
-        const val BASE_PRICE_CAN = 100
-        const val SALE_PRICE_CAN = 80
-        val NOW: LocalDateTime = LocalDateTime.of(2026, 9, 29, 12, 0)
-
-        @JvmStatic
-        fun invalidGiftApplicationScenarios() = listOf(
-            InvalidGiftApplicationScenario(validGiftApplicationCommand().copy(senderName = "")),
-            InvalidGiftApplicationScenario(validGiftApplicationCommand().copy(senderPhoneNumber = "")),
-            InvalidGiftApplicationScenario(validGiftApplicationCommand().copy(senderZipCode = "")),
-            InvalidGiftApplicationScenario(validGiftApplicationCommand().copy(senderAddress = "")),
-            InvalidGiftApplicationScenario(validGiftApplicationCommand().copy(senderTermsAgreed = false)),
-            InvalidGiftApplicationScenario(validGiftApplicationCommand().copy(senderPrivacyAgreed = false)),
-            InvalidGiftApplicationScenario(validGiftApplicationCommand(), categoryActive = false),
-            InvalidGiftApplicationScenario(
-                validGiftApplicationCommand().copy(damageWaiverAgreed = false),
-                requiresDamageWaiver = true
-            ),
-            InvalidGiftApplicationScenario(validGiftApplicationCommand(), sizePriceActive = false),
-            InvalidGiftApplicationScenario(validGiftApplicationCommand(), creatorExists = false)
-        )
-
-        @JvmStatic
-        fun invalidGiftCancellationScenarios() = listOf(
-            InvalidGiftCancellationScenario(OTHER_MEMBER_ID, SENDER_ID, GiftStatus.RECEIVED),
-            InvalidGiftCancellationScenario(SENDER_ID, SENDER_ID, GiftStatus.TRACKING_REGISTERED)
-        )
-
-        @JvmStatic
-        fun invalidGiftTrackingRegistrationScenarios() = listOf(
-            InvalidGiftTrackingRegistrationScenario(requesterMemberId = OTHER_MEMBER_ID),
-            InvalidGiftTrackingRegistrationScenario(status = GiftStatus.TRACKING_REGISTERED),
-            InvalidGiftTrackingRegistrationScenario(
-                command = validGiftTrackingRegistrationCommand().copy(courierCompanyName = "")
-            ),
-            InvalidGiftTrackingRegistrationScenario(
-                command = validGiftTrackingRegistrationCommand().copy(courierCompanyName = "a".repeat(51))
-            ),
-            InvalidGiftTrackingRegistrationScenario(
-                command = validGiftTrackingRegistrationCommand().copy(trackingNumber = "")
-            ),
-            InvalidGiftTrackingRegistrationScenario(deliveryExists = false)
-        )
-
-        @JvmStatic
-        fun recipientAddressRegistrableStatuses() = listOf(
-            GiftStatus.TRACKING_REGISTERED,
-            GiftStatus.ARRIVED_AT_MAILBOX,
-            GiftStatus.INSPECTION_COMPLETED
-        )
-
-        @JvmStatic
-        fun invalidGiftRecipientAddressRegistrationScenarios() = listOf(
-            InvalidGiftRecipientAddressRegistrationScenario(requesterMemberId = OTHER_MEMBER_ID),
-            InvalidGiftRecipientAddressRegistrationScenario(status = GiftStatus.RECEIVED),
-            InvalidGiftRecipientAddressRegistrationScenario(status = GiftStatus.DELIVERED),
-            InvalidGiftRecipientAddressRegistrationScenario(status = GiftStatus.UNDELIVERABLE),
-            InvalidGiftRecipientAddressRegistrationScenario(status = GiftStatus.CANCELED),
-            InvalidGiftRecipientAddressRegistrationScenario(
-                command = validGiftRecipientAddressRegistrationCommand().copy(name = "")
-            ),
-            InvalidGiftRecipientAddressRegistrationScenario(
-                command = validGiftRecipientAddressRegistrationCommand().copy(phoneNumber = "")
-            ),
-            InvalidGiftRecipientAddressRegistrationScenario(
-                command = validGiftRecipientAddressRegistrationCommand().copy(zipCode = "")
-            ),
-            InvalidGiftRecipientAddressRegistrationScenario(
-                command = validGiftRecipientAddressRegistrationCommand().copy(address = "")
-            ),
-            InvalidGiftRecipientAddressRegistrationScenario(
-                command = validGiftRecipientAddressRegistrationCommand().copy(recipientTermsAgreed = false)
-            ),
-            InvalidGiftRecipientAddressRegistrationScenario(
-                command = validGiftRecipientAddressRegistrationCommand().copy(recipientPrivacyAgreed = false)
-            ),
-            InvalidGiftRecipientAddressRegistrationScenario(deliveryExists = false)
-        )
-
-        @JvmStatic
-        fun invalidGiftDeliveryConfirmationScenarios() = listOf(
-            InvalidGiftDeliveryConfirmationScenario(requesterMemberId = OTHER_MEMBER_ID),
-            InvalidGiftDeliveryConfirmationScenario(status = GiftStatus.TRACKING_REGISTERED),
-            InvalidGiftDeliveryConfirmationScenario(status = GiftStatus.DELIVERED),
-            InvalidGiftDeliveryConfirmationScenario(deliveryExists = false)
-        )
-
-        @JvmStatic
-        fun invalidGiftReviewScenarios() = listOf(
-            InvalidGiftReviewScenario(requesterMemberId = OTHER_MEMBER_ID),
-            InvalidGiftReviewScenario(status = GiftStatus.INSPECTION_COMPLETED),
-            InvalidGiftReviewScenario(reviewExists = true),
-            InvalidGiftReviewScenario(command = validGiftReviewCommand().copy(rating = 0)),
-            InvalidGiftReviewScenario(command = validGiftReviewCommand().copy(rating = 6)),
-            InvalidGiftReviewScenario(command = validGiftReviewCommand().copy(keywords = listOf("a".repeat(256)))),
-            InvalidGiftReviewScenario(command = validGiftReviewCommand().copy(comment = "a".repeat(256)))
-        )
-
-        fun validGiftApplicationCommand() = GiftApplicationCommand(
-            recipientMemberId = RECIPIENT_ID,
-            senderName = "홍길동",
-            senderPhoneNumber = "01012345678",
-            senderZipCode = "06234",
-            senderAddress = "서울시 강남구",
-            senderAddressDetail = "101동 1001호",
-            sizeCode = GiftSize.SMALL,
-            categoryId = CATEGORY_ID,
-            senderTermsAgreed = true,
-            senderPrivacyAgreed = true,
-            damageWaiverAgreed = true
-        )
-
-        fun validGiftTrackingRegistrationCommand() = GiftTrackingRegistrationCommand(
-            courierCompanyName = "CJ대한통운",
-            trackingNumber = "1234567890"
-        )
-
-        fun validGiftRecipientAddressRegistrationCommand() = GiftRecipientAddressRegistrationCommand(
-            name = "김소다",
-            phoneNumber = "01098765432",
-            zipCode = "04524",
-            address = "서울시 중구",
-            addressDetail = "202호",
-            recipientTermsAgreed = true,
-            recipientPrivacyAgreed = true
-        )
-
-        fun validGiftReviewCommand() = GiftReviewCommand(
-            rating = 5,
-            keywords = listOf("배송이 빨라요", "안내가 친절해요"),
-            comment = "선물 전달 과정이 만족스러웠습니다."
-        )
-    }
-}
@@ -1,156 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence
-
-import kr.co.vividnext.sodalive.configs.QueryDslConfig
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftSize
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Assertions.assertNotNull
-import org.junit.jupiter.api.Assertions.assertThrows
-import org.junit.jupiter.api.DisplayName
-import org.junit.jupiter.api.Test
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
-import org.springframework.context.annotation.Import
-import org.springframework.dao.DataIntegrityViolationException
-import java.time.LocalDateTime
-
-@DataJpaTest(
-    properties = [
-        "spring.cache.type=none",
-        "spring.datasource.url=jdbc:h2:mem:testdb;MODE=MySQL;NON_KEYWORDS=VALUE"
-    ]
-)
-@Import(QueryDslConfig::class)
-@DisplayName("선물 엔티티 매핑 테스트")
-class GiftEntityMappingTest @Autowired constructor(
-    private val giftRepository: GiftRepository,
-    private val giftDeliveryRepository: GiftDeliveryRepository,
-    private val giftCategoryRepository: GiftCategoryRepository,
-    private val giftSizePriceRepository: GiftSizePriceRepository,
-    private val giftReviewRepository: GiftReviewRepository,
-    private val giftApplicationNoSequenceRepository: GiftApplicationNoSequenceRepository
-) {
-    @Test
-    @DisplayName("선물 엔티티와 배송 정보를 저장하고 조회한다")
-    fun shouldSaveAndFindGiftWithDelivery() {
-        val category = giftCategoryRepository.save(
-            GiftCategory(
-                classificationNumber = "100",
-                categoryCode = "DOLL",
-                name = "인형",
-                receiptCode = "A",
-                representativeItem = "피규어",
-                requiresDamageWaiver = true
-            )
-        )
-        giftSizePriceRepository.save(
-            GiftSizePrice(
-                sizeCode = GiftSize.SMALL,
-                basePriceCan = 100,
-                salePriceCan = 80
-            )
-        )
-        val gift = giftRepository.save(
-            Gift(
-                applicationNo = "G20260929000001",
-                senderMemberId = 1L,
-                recipientMemberId = 2L,
-                status = GiftStatus.RECEIVED,
-                sizeCode = GiftSize.SMALL,
-                categoryId = category.id!!,
-                categoryNameSnapshot = category.name,
-                salePriceCan = 80,
-                canUsageId = 10L,
-                senderTermsAgreed = true,
-                senderPrivacyAgreed = true,
-                senderTermsAgreedAt = LocalDateTime.of(2026, 9, 29, 12, 0),
-                senderPrivacyAgreedAt = LocalDateTime.of(2026, 9, 29, 12, 0),
-                damageWaiverAgreed = true
-            )
-        )
-
-        giftDeliveryRepository.save(
-            GiftDelivery(
-                giftId = gift.id!!,
-                senderName = "홍길동",
-                senderPhoneNumber = "01012345678",
-                senderZipCode = "06234",
-                senderAddress = "서울시 강남구",
-                senderAddressDetail = "101동 1001호",
-                trackingDeadlineAt = LocalDateTime.of(2026, 10, 2, 12, 0)
-            )
-        )
-
-        val saved = giftRepository.findByApplicationNo("G20260929000001")
-        val delivery = giftDeliveryRepository.findByGiftId(gift.id!!)
-
-        assertNotNull(saved)
-        assertEquals(GiftStatus.RECEIVED, saved!!.status)
-        assertEquals("홍길동", delivery!!.senderName)
-        assertNotNull(saved.createdAt)
-        assertNotNull(saved.updatedAt)
-    }
-
-    @Test
-    @DisplayName("신청번호와 카테고리 unique 값과 리뷰 선물 ID는 중복 저장할 수 없다")
-    fun shouldRejectDuplicateUniqueValues() {
-        val category = giftCategoryRepository.save(giftCategory("100", "DOLL", "A"))
-        val gift = giftRepository.save(gift(category.id!!, "G20260929000001"))
-        giftRepository.saveAndFlush(gift(category.id!!, "G20260929000002"))
-        giftReviewRepository.saveAndFlush(GiftReview(giftId = gift.id!!, senderMemberId = 1L, rating = 5))
-
-        assertThrows(DataIntegrityViolationException::class.java) {
-            giftRepository.saveAndFlush(gift(category.id!!, "G20260929000001"))
-        }
-        assertThrows(DataIntegrityViolationException::class.java) {
-            giftCategoryRepository.saveAndFlush(giftCategory("101", "DOLL", "B"))
-        }
-        assertThrows(DataIntegrityViolationException::class.java) {
-            giftCategoryRepository.saveAndFlush(giftCategory("100", "TOY", "B"))
-        }
-        assertThrows(DataIntegrityViolationException::class.java) {
-            giftCategoryRepository.saveAndFlush(giftCategory("101", "TOY", "A"))
-        }
-        assertThrows(DataIntegrityViolationException::class.java) {
-            giftReviewRepository.saveAndFlush(GiftReview(giftId = gift.id!!, senderMemberId = 1L, rating = 4))
-        }
-    }
-
-    @Test
-    @DisplayName("카테고리와 날짜별 신청번호 채번 sequence를 저장한다")
-    fun shouldSaveApplicationNoSequence() {
-        val category = giftCategoryRepository.save(giftCategory("100", "DOLL", "A"))
-        val sequence = giftApplicationNoSequenceRepository.save(
-            GiftApplicationNoSequence(categoryId = category.id!!, sequenceDate = "260929", lastSequence = 1)
-        )
-
-        assertEquals(category.id, sequence.categoryId)
-        assertEquals("260929", sequence.sequenceDate)
-        assertEquals(1, sequence.lastSequence)
-    }
-
-    private fun gift(categoryId: Long, applicationNo: String) = Gift(
-        applicationNo = applicationNo,
-        senderMemberId = 1L,
-        recipientMemberId = 2L,
-        status = GiftStatus.RECEIVED,
-        sizeCode = GiftSize.SMALL,
-        categoryId = categoryId,
-        categoryNameSnapshot = "인형",
-        salePriceCan = 80,
-        canUsageId = 10L,
-        senderTermsAgreed = true,
-        senderPrivacyAgreed = true,
-        senderTermsAgreedAt = LocalDateTime.of(2026, 9, 29, 12, 0),
-        senderPrivacyAgreedAt = LocalDateTime.of(2026, 9, 29, 12, 0),
-        damageWaiverAgreed = true
-    )
-
-    private fun giftCategory(classificationNumber: String, categoryCode: String, receiptCode: String) = GiftCategory(
-        classificationNumber = classificationNumber,
-        categoryCode = categoryCode,
-        name = "인형",
-        receiptCode = receiptCode,
-        representativeItem = "피규어"
-    )
-}
@@ -1,287 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.adapter.out.scheduler
-
-import kr.co.vividnext.sodalive.can.payment.CanPaymentService
-import kr.co.vividnext.sodalive.configs.QueryDslConfig
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.Gift
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDelivery
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDeliveryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftRepository
-import kr.co.vividnext.sodalive.v2.gift.application.GiftPushService
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftSize
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.DisplayName
-import org.junit.jupiter.api.Test
-import org.mockito.Mockito
-import org.redisson.api.RedissonClient
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
-import org.springframework.context.annotation.Import
-import java.time.LocalDateTime
-
-@DataJpaTest(
-    properties = [
-        "spring.cache.type=none",
-        "spring.datasource.url=jdbc:h2:mem:testdb;MODE=MySQL;NON_KEYWORDS=VALUE"
-    ]
-)
-@Import(QueryDslConfig::class)
-@DisplayName("선물 자동처리 스케줄러 테스트")
-class GiftSchedulerTest @Autowired constructor(
-    private val giftRepository: GiftRepository,
-    private val giftDeliveryRepository: GiftDeliveryRepository
-) {
-    private val canPaymentService = Mockito.mock(CanPaymentService::class.java)
-    private val giftPushService = Mockito.mock(GiftPushService::class.java)
-    private val scheduler = GiftScheduler(
-        giftRepository,
-        giftDeliveryRepository,
-        canPaymentService,
-        giftPushService,
-        Mockito.mock(RedissonClient::class.java)
-    )
-
-    @Test
-    @DisplayName("운송장 등록 기한이 지난 접수 선물을 취소하고 한 번 환불한다")
-    fun shouldCancelOverdueReceivedGiftAndRefundOnce() {
-        val now = LocalDateTime.of(2026, 10, 2, 12, 0)
-        val (gift, delivery) = saveGift(GiftStatus.RECEIVED, now.minusSeconds(1))
-
-        val canceledCount = scheduler.cancelExpiredTrackingRegistrationGifts(now)
-
-        assertEquals(1, canceledCount)
-        assertEquals(GiftStatus.CANCELED, gift.status)
-        assertEquals(now, delivery.canceledAt)
-        Mockito.verify(canPaymentService).refundGiftCan(SENDER_MEMBER_ID, CAN_USAGE_ID)
-        Mockito.verify(giftPushService).sendAutoCanceledToSender(APPLICATION_NO, SENDER_MEMBER_ID)
-    }
-
-    @Test
-    @DisplayName("운송장 등록 기한과 같은 접수 선물은 취소하지 않는다")
-    fun shouldIgnoreReceivedGiftWhoseTrackingDeadlineIsNotPast() {
-        val now = LocalDateTime.of(2026, 10, 2, 12, 0)
-        val (gift, delivery) = saveGift(GiftStatus.RECEIVED, now)
-
-        val canceledCount = scheduler.cancelExpiredTrackingRegistrationGifts(now)
-
-        assertEquals(0, canceledCount)
-        assertEquals(GiftStatus.RECEIVED, gift.status)
-        assertEquals(null, delivery.canceledAt)
-        Mockito.verifyNoInteractions(canPaymentService)
-    }
-
-    @Test
-    @DisplayName("운송장 등록 기한이 지나도 접수 상태가 아닌 선물은 취소하지 않는다")
-    fun shouldIgnoreOverdueGiftThatIsNotReceived() {
-        val now = LocalDateTime.of(2026, 10, 2, 12, 0)
-        val (gift, delivery) = saveGift(GiftStatus.TRACKING_REGISTERED, now.minusSeconds(1))
-
-        val canceledCount = scheduler.cancelExpiredTrackingRegistrationGifts(now)
-
-        assertEquals(0, canceledCount)
-        assertEquals(GiftStatus.TRACKING_REGISTERED, gift.status)
-        assertEquals(null, delivery.canceledAt)
-        Mockito.verifyNoInteractions(canPaymentService)
-    }
-
-    @Test
-    @DisplayName("자동취소를 다시 실행해도 이미 취소된 선물은 환불하지 않는다")
-    fun shouldNotRefundAlreadyCanceledGiftOnSecondRun() {
-        val now = LocalDateTime.of(2026, 10, 2, 12, 0)
-        saveGift(GiftStatus.RECEIVED, now.minusSeconds(1))
-
-        val firstCanceledCount = scheduler.cancelExpiredTrackingRegistrationGifts(now)
-        val secondCanceledCount = scheduler.cancelExpiredTrackingRegistrationGifts(now)
-
-        assertEquals(1, firstCanceledCount)
-        assertEquals(0, secondCanceledCount)
-        Mockito.verify(canPaymentService, Mockito.times(1)).refundGiftCan(SENDER_MEMBER_ID, CAN_USAGE_ID)
-        Mockito.verify(giftPushService, Mockito.times(1)).sendAutoCanceledToSender(APPLICATION_NO, SENDER_MEMBER_ID)
-    }
-
-    @Test
-    @DisplayName("배송지 입력 기한이 지난 발송 확인 선물을 전달 불가 처리한다")
-    fun shouldMarkOverdueTrackingRegisteredGiftWithoutRecipientAddressUndeliverable() {
-        val now = LocalDateTime.of(2026, 10, 9, 12, 0)
-        val (gift, delivery) = saveGift(
-            status = GiftStatus.TRACKING_REGISTERED,
-            trackingDeadlineAt = now.minusDays(7),
-            recipientAddressDeadlineAt = now.minusSeconds(1)
-        )
-
-        val updatedCount = scheduler.markExpiredRecipientAddressGiftsUndeliverable(now)
-
-        assertEquals(1, updatedCount)
-        assertEquals(GiftStatus.UNDELIVERABLE, gift.status)
-        assertEquals(now, delivery.undeliverableAt)
-        assertEquals("배송지 미입력 기한 초과", delivery.undeliverableReason)
-    }
-
-    @Test
-    @DisplayName("배송지 입력 기한과 같은 발송 확인 선물은 전달 불가 처리하지 않는다")
-    fun shouldIgnoreTrackingRegisteredGiftWhoseRecipientAddressDeadlineIsNotPast() {
-        val now = LocalDateTime.of(2026, 10, 9, 12, 0)
-        val (gift, delivery) = saveGift(
-            status = GiftStatus.TRACKING_REGISTERED,
-            trackingDeadlineAt = now.minusDays(7),
-            recipientAddressDeadlineAt = now
-        )
-
-        val updatedCount = scheduler.markExpiredRecipientAddressGiftsUndeliverable(now)
-
-        assertEquals(0, updatedCount)
-        assertEquals(GiftStatus.TRACKING_REGISTERED, gift.status)
-        assertEquals(null, delivery.undeliverableAt)
-        assertEquals(null, delivery.undeliverableReason)
-    }
-
-    @Test
-    @DisplayName("배송지가 입력된 선물은 배송지 입력 기한이 지나도 전달 불가 처리하지 않는다")
-    fun shouldIgnoreGiftWithRecipientAddress() {
-        val now = LocalDateTime.of(2026, 10, 9, 12, 0)
-        val (gift, delivery) = saveGift(
-            status = GiftStatus.TRACKING_REGISTERED,
-            trackingDeadlineAt = now.minusDays(7),
-            recipientAddressDeadlineAt = now.minusSeconds(1),
-            recipientAddress = "서울시 송파구"
-        )
-
-        val updatedCount = scheduler.markExpiredRecipientAddressGiftsUndeliverable(now)
-
-        assertEquals(0, updatedCount)
-        assertEquals(GiftStatus.TRACKING_REGISTERED, gift.status)
-        assertEquals(null, delivery.undeliverableAt)
-        assertEquals(null, delivery.undeliverableReason)
-    }
-
-    @Test
-    @DisplayName("배송지 미입력 전달 불가를 다시 실행해도 이미 전달 불가인 선물은 처리하지 않는다")
-    fun shouldNotUpdateAlreadyUndeliverableGiftOnSecondRun() {
-        val now = LocalDateTime.of(2026, 10, 9, 12, 0)
-        val (_, delivery) = saveGift(
-            status = GiftStatus.TRACKING_REGISTERED,
-            trackingDeadlineAt = now.minusDays(7),
-            recipientAddressDeadlineAt = now.minusSeconds(1)
-        )
-
-        val firstUpdatedCount = scheduler.markExpiredRecipientAddressGiftsUndeliverable(now)
-        val secondUpdatedCount = scheduler.markExpiredRecipientAddressGiftsUndeliverable(now.plusMinutes(1))
-
-        assertEquals(1, firstUpdatedCount)
-        assertEquals(0, secondUpdatedCount)
-        assertEquals(now, delivery.undeliverableAt)
-    }
-
-    @Test
-    @DisplayName("운송장 등록 기한 24시간 전 접수 선물에 한 번만 안내한다")
-    fun shouldSendTrackingDeadlineReminderOnce() {
-        val now = LocalDateTime.of(2026, 10, 1, 12, 0)
-        val (_, delivery) = saveGift(GiftStatus.RECEIVED, now.plusHours(24))
-
-        val firstSentCount = scheduler.sendDeadlineReminderGifts(now)
-        val secondSentCount = scheduler.sendDeadlineReminderGifts(now.plusMinutes(1))
-
-        assertEquals(1, firstSentCount)
-        assertEquals(0, secondSentCount)
-        assertEquals(now, delivery.trackingDeadlineReminderSentAt)
-        Mockito.verify(giftPushService, Mockito.times(1)).sendTrackingDeadlineReminder(APPLICATION_NO, SENDER_MEMBER_ID)
-    }
-
-    @Test
-    @DisplayName("운송장 등록 기한 24시간 초과 전 접수 선물은 안내하지 않는다")
-    fun shouldIgnoreTrackingDeadlineReminderBeforeWindow() {
-        val now = LocalDateTime.of(2026, 10, 1, 12, 0)
-        saveGift(GiftStatus.RECEIVED, now.plusHours(24).plusSeconds(1))
-
-        val sentCount = scheduler.sendDeadlineReminderGifts(now)
-
-        assertEquals(0, sentCount)
-        Mockito.verifyNoInteractions(giftPushService)
-    }
-
-    @Test
-    @DisplayName("배송지 입력 기한 24시간 전 선물에 한 번만 안내한다")
-    fun shouldSendRecipientAddressDeadlineReminderOnce() {
-        val now = LocalDateTime.of(2026, 10, 8, 12, 0)
-        val (_, delivery) = saveGift(
-            status = GiftStatus.TRACKING_REGISTERED,
-            trackingDeadlineAt = now.minusDays(6),
-            recipientAddressDeadlineAt = now.plusHours(24)
-        )
-
-        val firstSentCount = scheduler.sendDeadlineReminderGifts(now)
-        val secondSentCount = scheduler.sendDeadlineReminderGifts(now.plusMinutes(1))
-
-        assertEquals(1, firstSentCount)
-        assertEquals(0, secondSentCount)
-        assertEquals(now, delivery.recipientAddressDeadlineReminderSentAt)
-        Mockito.verify(giftPushService, Mockito.times(1))
-            .sendRecipientAddressDeadlineReminder(APPLICATION_NO, RECIPIENT_MEMBER_ID)
-    }
-
-    @Test
-    @DisplayName("배송지가 입력된 선물은 배송지 입력 기한 안내를 보내지 않는다")
-    fun shouldIgnoreRecipientAddressDeadlineReminderWhenAddressExists() {
-        val now = LocalDateTime.of(2026, 10, 8, 12, 0)
-        saveGift(
-            status = GiftStatus.TRACKING_REGISTERED,
-            trackingDeadlineAt = now.minusDays(6),
-            recipientAddressDeadlineAt = now.plusHours(24),
-            recipientAddress = "서울시 송파구"
-        )
-
-        val sentCount = scheduler.sendDeadlineReminderGifts(now)
-
-        assertEquals(0, sentCount)
-        Mockito.verifyNoInteractions(giftPushService)
-    }
-
-    private fun saveGift(
-        status: GiftStatus,
-        trackingDeadlineAt: LocalDateTime,
-        recipientAddressDeadlineAt: LocalDateTime? = null,
-        recipientAddress: String? = null
-    ): Pair<Gift, GiftDelivery> {
-        val gift = giftRepository.save(
-            Gift(
-                applicationNo = APPLICATION_NO,
-                senderMemberId = SENDER_MEMBER_ID,
-                recipientMemberId = RECIPIENT_MEMBER_ID,
-                status = status,
-                sizeCode = GiftSize.SMALL,
-                categoryId = CATEGORY_ID,
-                categoryNameSnapshot = "인형",
-                salePriceCan = 80,
-                canUsageId = CAN_USAGE_ID,
-                senderTermsAgreed = true,
-                senderPrivacyAgreed = true,
-                senderTermsAgreedAt = APPLIED_AT,
-                senderPrivacyAgreedAt = APPLIED_AT,
-                damageWaiverAgreed = true
-            )
-        )
-        val delivery = giftDeliveryRepository.save(
-            GiftDelivery(
-                giftId = requireNotNull(gift.id),
-                senderName = "홍길동",
-                senderPhoneNumber = "01012345678",
-                senderZipCode = "06234",
-                senderAddress = "서울시 강남구",
-                recipientAddress = recipientAddress,
-                trackingDeadlineAt = trackingDeadlineAt,
-                recipientAddressDeadlineAt = recipientAddressDeadlineAt
-            )
-        )
-
-        return gift to delivery
-    }
-
-    private companion object {
-        const val APPLICATION_NO = "G20260929000001"
-        const val SENDER_MEMBER_ID = 1L
-        const val RECIPIENT_MEMBER_ID = 2L
-        const val CATEGORY_ID = 3L
-        const val CAN_USAGE_ID = 4L
-        val APPLIED_AT: LocalDateTime = LocalDateTime.of(2026, 9, 29, 12, 0)
-    }
-}
@@ -1,228 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.application
-
-import kr.co.vividnext.sodalive.common.SodaException
-import kr.co.vividnext.sodalive.configs.QueryDslConfig
-import kr.co.vividnext.sodalive.member.Member
-import kr.co.vividnext.sodalive.member.MemberRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.Gift
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategory
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategoryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDelivery
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDeliveryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftRepository
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftSize
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Assertions.assertThrows
-import org.junit.jupiter.api.DisplayName
-import org.junit.jupiter.api.Test
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
-import org.springframework.context.annotation.Import
-import java.time.LocalDateTime
-
-@DataJpaTest(
-    properties = [
-        "spring.cache.type=none",
-        "spring.datasource.url=jdbc:h2:mem:gift-admin-query;MODE=MySQL;NON_KEYWORDS=VALUE"
-    ]
-)
-@Import(QueryDslConfig::class)
-@DisplayName("관리자 선물함 조회 서비스 테스트")
-class GiftAdminQueryServiceTest @Autowired constructor(
-    private val giftRepository: GiftRepository,
-    private val deliveryRepository: GiftDeliveryRepository,
-    private val categoryRepository: GiftCategoryRepository,
-    private val memberRepository: MemberRepository
-) {
-    @Test
-    @DisplayName("관리자는 선물함 목록을 필터링하고 가능한 액션을 조회한다")
-    fun shouldListAdminGiftsWithFiltersAndAvailableActions() {
-        val sender = saveMember("fan-alpha")
-        val recipient = saveMember("creator-alpha")
-        val otherSender = saveMember("fan-beta")
-        val otherRecipient = saveMember("creator-beta")
-        val category = saveCategory()
-        saveGift(
-            applicationNo = "A-1002609300001",
-            sender = sender,
-            recipient = recipient,
-            category = category,
-            status = GiftStatus.TRACKING_REGISTERED,
-            withTracking = true
-        )
-        saveGift(
-            applicationNo = "A-1002609300002",
-            sender = otherSender,
-            recipient = otherRecipient,
-            category = category,
-            status = GiftStatus.RECEIVED
-        )
-
-        val result = service().getGifts(
-            status = GiftStatus.TRACKING_REGISTERED,
-            applicationNo = "0001",
-            nickname = "alpha",
-            page = 0,
-            size = 20
-        )
-
-        assertEquals(1L, result.totalCount)
-        assertEquals(1, result.items.size)
-        assertEquals(0, result.page)
-        assertEquals(20, result.size)
-        assertEquals(false, result.hasNext)
-        val item = result.items.single()
-        assertEquals("A-1002609300001", item.applicationNo)
-        assertEquals("fan-alpha", item.senderNickname)
-        assertEquals("creator-alpha", item.recipientNickname)
-        assertEquals("SMALL", item.sizeCode)
-        assertEquals("소형", item.sizeName)
-        assertEquals("인형", item.categoryName)
-        assertEquals("100", item.classificationNumber)
-        assertEquals("CJ대한통운", item.courierCompanyName)
-        assertEquals("1234567890", item.trackingNumber)
-        assertEquals(GiftStatus.TRACKING_REGISTERED, item.status)
-        assertEquals("발송 확인", item.statusName)
-        assertEquals(listOf("ARRIVE_MAILBOX", "MARK_UNDELIVERABLE"), item.availableActions)
-    }
-
-    @Test
-    @DisplayName("관리자는 선물 상세에서 개인정보와 상품 정보를 조회하고 미입력 수취인 정보는 빈 문자열로 받는다")
-    fun shouldGetAdminGiftDetailWithPersonalInformation() {
-        val sender = saveMember("fan-alpha")
-        val recipient = saveMember("creator-alpha")
-        val category = saveCategory()
-        saveGift(
-            applicationNo = "A-1002609300001",
-            sender = sender,
-            recipient = recipient,
-            category = category,
-            status = GiftStatus.ARRIVED_AT_MAILBOX,
-            withTracking = true
-        )
-
-        val result = service().getGiftDetail("A-1002609300001")
-
-        assertEquals("A-1002609300001", result.applicationNo)
-        assertEquals("fan-alpha", result.senderInfo.nickname)
-        assertEquals("홍길동", result.senderInfo.name)
-        assertEquals("01012345678", result.senderInfo.phoneNumber)
-        assertEquals("(06234) 서울시 강남구, 101동 1001호", result.senderInfo.address)
-        assertEquals("creator-alpha", result.recipientInfo.nickname)
-        assertEquals("", result.recipientInfo.name)
-        assertEquals("", result.recipientInfo.phoneNumber)
-        assertEquals("", result.recipientInfo.address)
-        assertEquals("SMALL", result.productInfo.sizeCode)
-        assertEquals("소형", result.productInfo.sizeName)
-        assertEquals("인형", result.productInfo.categoryName)
-        assertEquals("100", result.productInfo.classificationNumber)
-        assertEquals("CJ대한통운", result.inboundDeliveryInfo.courierCompanyName)
-        assertEquals("1234567890", result.inboundDeliveryInfo.trackingNumber)
-        assertEquals(GiftStatus.ARRIVED_AT_MAILBOX, result.status)
-        assertEquals("사서함 도착", result.statusName)
-        assertEquals(listOf("COMPLETE_INSPECTION", "MARK_UNDELIVERABLE"), result.availableActions)
-    }
-
-    @Test
-    @DisplayName("관리자 선물 상세는 상태별 가능한 액션을 반환하고 없는 신청번호를 거부한다")
-    fun shouldReturnAvailableActionsByStatusAndRejectUnknownApplicationNo() {
-        val sender = saveMember("fan-alpha")
-        val recipient = saveMember("creator-alpha")
-        val category = saveCategory()
-        GiftStatus.values().forEachIndexed { index, status ->
-            saveGift("A-10026093010$index", sender, recipient, category, status)
-        }
-
-        val service = service()
-
-        assertEquals(emptyList<String>(), service.getGiftDetail("A-100260930100").availableActions)
-        assertEquals(
-            listOf("ARRIVE_MAILBOX", "MARK_UNDELIVERABLE"),
-            service.getGiftDetail("A-100260930101").availableActions
-        )
-        assertEquals(
-            listOf("COMPLETE_INSPECTION", "MARK_UNDELIVERABLE"),
-            service.getGiftDetail("A-100260930102").availableActions
-        )
-        assertEquals(
-            listOf("COMPLETE_DELIVERY", "MARK_UNDELIVERABLE"),
-            service.getGiftDetail("A-100260930103").availableActions
-        )
-        assertEquals(emptyList<String>(), service.getGiftDetail("A-100260930104").availableActions)
-        assertEquals(emptyList<String>(), service.getGiftDetail("A-100260930105").availableActions)
-        assertEquals(emptyList<String>(), service.getGiftDetail("A-100260930106").availableActions)
-        val exception = assertThrows(SodaException::class.java) {
-            service.getGiftDetail("UNKNOWN")
-        }
-        assertEquals("common.error.invalid_request", exception.messageKey)
-    }
-
-    private fun service() = GiftAdminQueryService(
-        giftRepository = giftRepository,
-        deliveryRepository = deliveryRepository,
-        categoryRepository = categoryRepository,
-        memberRepository = memberRepository
-    )
-
-    private fun saveMember(nickname: String) = memberRepository.save(Member(password = "password", nickname = nickname))
-
-    private fun saveCategory() = categoryRepository.save(
-        GiftCategory(
-            classificationNumber = "100",
-            categoryCode = "DOLL",
-            name = "인형",
-            receiptCode = "A",
-            representativeItem = "피규어"
-        )
-    )
-
-    private fun saveGift(
-        applicationNo: String,
-        sender: Member,
-        recipient: Member,
-        category: GiftCategory,
-        status: GiftStatus,
-        withTracking: Boolean = false
-    ): Gift {
-        val gift = giftRepository.save(
-            Gift(
-                applicationNo = applicationNo,
-                senderMemberId = sender.id!!,
-                recipientMemberId = recipient.id!!,
-                status = status,
-                sizeCode = GiftSize.SMALL,
-                categoryId = category.id!!,
-                categoryNameSnapshot = category.name,
-                salePriceCan = 80,
-                canUsageId = 10L,
-                senderTermsAgreed = true,
-                senderPrivacyAgreed = true,
-                senderTermsAgreedAt = NOW,
-                senderPrivacyAgreedAt = NOW
-            )
-        )
-        deliveryRepository.save(
-            GiftDelivery(
-                giftId = gift.id!!,
-                senderName = "홍길동",
-                senderPhoneNumber = "01012345678",
-                senderZipCode = "06234",
-                senderAddress = "서울시 강남구",
-                senderAddressDetail = "101동 1001호",
-                trackingDeadlineAt = NOW.plusDays(3)
-            ).apply {
-                if (withTracking) {
-                    courierCompanyName = "CJ대한통운"
-                    trackingNumber = "1234567890"
-                    trackingRegisteredAt = NOW.plusHours(1)
-                }
-            }
-        )
-        return gift
-    }
-
-    private companion object {
-        val NOW: LocalDateTime = LocalDateTime.of(2026, 9, 30, 12, 0)
-    }
-}
@@ -1,277 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.application
-
-import kr.co.vividnext.sodalive.common.SodaException
-import kr.co.vividnext.sodalive.configs.QueryDslConfig
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.Gift
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategoryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDelivery
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDeliveryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftSizePriceRepository
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftSize
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Assertions.assertFalse
-import org.junit.jupiter.api.Assertions.assertThrows
-import org.junit.jupiter.api.DisplayName
-import org.junit.jupiter.api.Test
-import org.mockito.Mockito
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
-import org.springframework.context.annotation.Import
-import java.time.LocalDateTime
-
-@DataJpaTest(
-    properties = [
-        "spring.cache.type=none",
-        "spring.datasource.url=jdbc:h2:mem:testdb;MODE=MySQL;NON_KEYWORDS=VALUE"
-    ]
-)
-@Import(QueryDslConfig::class)
-@DisplayName("선물 관리자 서비스 테스트")
-class GiftAdminServiceTest @Autowired constructor(
-    private val categoryRepository: GiftCategoryRepository,
-    private val sizePriceRepository: GiftSizePriceRepository,
-    private val giftRepository: GiftRepository,
-    private val giftDeliveryRepository: GiftDeliveryRepository
-) {
-    private val giftPushService = Mockito.mock(GiftPushService::class.java)
-    private val service = GiftAdminService(
-        categoryRepository,
-        sizePriceRepository,
-        giftRepository,
-        giftDeliveryRepository,
-        giftPushService
-    )
-
-    @Test
-    @DisplayName("카테고리를 등록, 수정, 논리삭제한다")
-    fun shouldCreateUpdateAndDeactivateCategory() {
-        val created = service.createCategory(
-            GiftCategoryCommand(
-                classificationNumber = "100",
-                categoryCode = "DOLL",
-                name = "인형",
-                receiptCode = "A",
-                representativeItem = "피규어",
-                requiresDamageWaiver = true,
-                isActive = true
-            )
-        )
-        val updated = service.updateCategory(
-            created.categoryId,
-            GiftCategoryCommand(
-                classificationNumber = "101",
-                categoryCode = "DOLL",
-                name = "큰 인형",
-                receiptCode = "B",
-                representativeItem = "대형 피규어",
-                requiresDamageWaiver = false,
-                isActive = true
-            )
-        )
-        service.deleteCategory(created.categoryId)
-
-        val saved = categoryRepository.findById(created.categoryId).orElseThrow()
-        assertEquals("101", updated.classificationNumber)
-        assertEquals("DOLL", updated.categoryCode)
-        assertEquals("큰 인형", updated.name)
-        assertEquals("B", updated.receiptCode)
-        assertEquals("대형 피규어", updated.representativeItem)
-        assertFalse(updated.requiresDamageWaiver)
-        assertFalse(saved.isActive)
-    }
-
-    @Test
-    @DisplayName("카테고리 분류번호와 접수코드 형식을 검증한다")
-    fun shouldValidateCategoryClassificationNumberAndReceiptCode() {
-        val invalidClassificationNumber = assertThrows(SodaException::class.java) {
-            service.createCategory(categoryCommand(classificationNumber = "10A"))
-        }
-        val invalidReceiptCode = assertThrows(SodaException::class.java) {
-            service.createCategory(categoryCommand(receiptCode = "A1"))
-        }
-        val blankRepresentativeItem = assertThrows(SodaException::class.java) {
-            service.createCategory(categoryCommand(representativeItem = " "))
-        }
-
-        assertEquals("common.error.invalid_request", invalidClassificationNumber.messageKey)
-        assertEquals("common.error.invalid_request", invalidReceiptCode.messageKey)
-        assertEquals("common.error.invalid_request", blankRepresentativeItem.messageKey)
-    }
-
-    @Test
-    @DisplayName("사이즈 가격을 수정하고 salePriceCan이 basePriceCan보다 크면 거부한다")
-    fun shouldUpdateSizePriceAndRejectInvalidSalePrice() {
-        val updated = service.updateSizePrice(
-            GiftSize.SMALL,
-            GiftSizePriceCommand(basePriceCan = 100, salePriceCan = 80, isActive = true)
-        )
-
-        val exception = assertThrows(SodaException::class.java) {
-            service.updateSizePrice(
-                GiftSize.SMALL,
-                GiftSizePriceCommand(basePriceCan = 100, salePriceCan = 101, isActive = true)
-            )
-        }
-
-        assertEquals(GiftSize.SMALL, updated.sizeCode)
-        assertEquals(80, updated.salePriceCan)
-        assertEquals("common.error.invalid_request", exception.messageKey)
-    }
-
-    @Test
-    @DisplayName("운영자는 발송 확인 선물을 사서함 도착 처리한다")
-    fun shouldMarkTrackingRegisteredGiftArrivedAtMailbox() {
-        val (gift, delivery) = saveGift(GiftStatus.TRACKING_REGISTERED)
-
-        val result = service.arriveMailbox(APPLICATION_NO, NOW)
-
-        assertEquals(GiftStatus.ARRIVED_AT_MAILBOX, result.status)
-        assertEquals(GiftStatus.ARRIVED_AT_MAILBOX, gift.status)
-        assertEquals(NOW, delivery.arrivedAtMailboxAt)
-        Mockito.verify(giftPushService).sendArrivedAtMailboxToSender(APPLICATION_NO, SENDER_MEMBER_ID)
-        Mockito.verify(giftPushService).sendArrivedAtMailboxToRecipient(APPLICATION_NO, RECIPIENT_MEMBER_ID)
-    }
-
-    @Test
-    @DisplayName("사서함 도착 상태가 아니면 검수 완료 처리할 수 없다")
-    fun shouldRejectInspectionCompletionWhenGiftIsNotArrivedAtMailbox() {
-        saveGift(GiftStatus.TRACKING_REGISTERED)
-
-        val exception = assertThrows(SodaException::class.java) {
-            service.completeInspection(APPLICATION_NO, NOW)
-        }
-
-        assertEquals("common.error.invalid_request", exception.messageKey)
-    }
-
-    @Test
-    @DisplayName("운영자는 사서함 도착 선물을 검수 완료 처리한다")
-    fun shouldCompleteInspectionForArrivedAtMailboxGift() {
-        val (gift, delivery) = saveGift(GiftStatus.ARRIVED_AT_MAILBOX)
-
-        val result = service.completeInspection(APPLICATION_NO, NOW)
-
-        assertEquals(GiftStatus.INSPECTION_COMPLETED, result.status)
-        assertEquals(GiftStatus.INSPECTION_COMPLETED, gift.status)
-        assertEquals(NOW, delivery.inspectionCompletedAt)
-        Mockito.verify(giftPushService).sendInspectionCompleted(APPLICATION_NO, RECIPIENT_MEMBER_ID)
-    }
-
-    @Test
-    @DisplayName("운영자는 진행 중 선물을 전달 불가 처리한다")
-    fun shouldMarkActiveGiftUndeliverable() {
-        val (gift, delivery) = saveGift(GiftStatus.INSPECTION_COMPLETED)
-
-        val result = service.markUndeliverable(APPLICATION_NO, UNDELIVERABLE_REASON, NOW)
-
-        assertEquals(GiftStatus.UNDELIVERABLE, result.status)
-        assertEquals(GiftStatus.UNDELIVERABLE, gift.status)
-        assertEquals(NOW, delivery.undeliverableAt)
-        assertEquals(UNDELIVERABLE_REASON, delivery.undeliverableReason)
-        Mockito.verify(giftPushService).sendUndeliverableToSender(APPLICATION_NO, SENDER_MEMBER_ID)
-        Mockito.verify(giftPushService).sendUndeliverableToRecipient(APPLICATION_NO, RECIPIENT_MEMBER_ID)
-    }
-
-    @Test
-    @DisplayName("전달 불가 사유가 비어 있거나 종료 상태면 전달 불가 처리할 수 없다")
-    fun shouldRejectUndeliverableWhenReasonBlankOrGiftTerminated() {
-        saveGift(GiftStatus.DELIVERED)
-
-        val blankReasonException = assertThrows(SodaException::class.java) {
-            service.markUndeliverable(APPLICATION_NO, " ", NOW)
-        }
-        val terminatedStatusException = assertThrows(SodaException::class.java) {
-            service.markUndeliverable(APPLICATION_NO, UNDELIVERABLE_REASON, NOW)
-        }
-
-        assertEquals("common.error.invalid_request", blankReasonException.messageKey)
-        assertEquals("common.error.invalid_request", terminatedStatusException.messageKey)
-    }
-
-    @Test
-    @DisplayName("운영자는 검수 완료 선물을 전달 완료 처리한다")
-    fun shouldCompleteDeliveryForInspectionCompletedGift() {
-        val (gift, delivery) = saveGift(GiftStatus.INSPECTION_COMPLETED)
-
-        val result = service.completeDelivery(APPLICATION_NO, NOW)
-
-        assertEquals(GiftStatus.DELIVERED, result.status)
-        assertEquals(GiftStatus.DELIVERED, gift.status)
-        assertEquals(NOW, delivery.deliveredAt)
-        Mockito.verify(giftPushService).sendDeliveredToSender(APPLICATION_NO, SENDER_MEMBER_ID)
-        Mockito.verify(giftPushService).sendDeliveredToRecipient(APPLICATION_NO, RECIPIENT_MEMBER_ID)
-        Mockito.verifyNoMoreInteractions(giftPushService)
-    }
-
-    @Test
-    @DisplayName("검수 완료 상태가 아니면 운영 전달 완료 처리할 수 없다")
-    fun shouldRejectDeliveryCompletionWhenGiftIsNotInspectionCompleted() {
-        saveGift(GiftStatus.ARRIVED_AT_MAILBOX)
-
-        val exception = assertThrows(SodaException::class.java) {
-            service.completeDelivery(APPLICATION_NO, NOW)
-        }
-
-        assertEquals("common.error.invalid_request", exception.messageKey)
-    }
-
-    private fun saveGift(status: GiftStatus): Pair<Gift, GiftDelivery> {
-        val gift = giftRepository.save(
-            Gift(
-                applicationNo = APPLICATION_NO,
-                senderMemberId = SENDER_MEMBER_ID,
-                recipientMemberId = RECIPIENT_MEMBER_ID,
-                status = status,
-                sizeCode = GiftSize.SMALL,
-                categoryId = 1L,
-                categoryNameSnapshot = "인형",
-                salePriceCan = 80,
-                canUsageId = 10L,
-                senderTermsAgreed = true,
-                senderPrivacyAgreed = true,
-                senderTermsAgreedAt = NOW.minusDays(1),
-                senderPrivacyAgreedAt = NOW.minusDays(1),
-                damageWaiverAgreed = true
-            )
-        )
-        val delivery = giftDeliveryRepository.save(
-            GiftDelivery(
-                giftId = requireNotNull(gift.id),
-                senderName = "홍길동",
-                senderPhoneNumber = "01012345678",
-                senderZipCode = "06234",
-                senderAddress = "서울시 강남구",
-                trackingDeadlineAt = NOW.minusDays(1),
-                trackingRegisteredAt = NOW.minusHours(1)
-            )
-        )
-
-        return gift to delivery
-    }
-
-    private fun categoryCommand(
-        classificationNumber: String = "100",
-        categoryCode: String = "DOLL",
-        name: String = "인형",
-        receiptCode: String = "A",
-        representativeItem: String = "피규어"
-    ) = GiftCategoryCommand(
-        classificationNumber = classificationNumber,
-        categoryCode = categoryCode,
-        name = name,
-        receiptCode = receiptCode,
-        representativeItem = representativeItem,
-        requiresDamageWaiver = true,
-        isActive = true
-    )
-
-    private companion object {
-        const val APPLICATION_NO = "G20260929000001"
-        const val SENDER_MEMBER_ID = 1L
-        const val RECIPIENT_MEMBER_ID = 2L
-        const val UNDELIVERABLE_REASON = "선물 접수 규격에 맞지 않습니다."
-        val NOW: LocalDateTime = LocalDateTime.of(2026, 10, 3, 12, 0)
-    }
-}
@@ -1,115 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.application
-
-import kr.co.vividnext.sodalive.configs.QueryDslConfig
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftApplicationNoSequence
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftApplicationNoSequenceRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategory
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategoryRepository
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.BeforeEach
-import org.junit.jupiter.api.DisplayName
-import org.junit.jupiter.api.Test
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
-import org.springframework.context.annotation.Import
-import org.springframework.transaction.PlatformTransactionManager
-import java.time.LocalDateTime
-import java.util.concurrent.Callable
-import java.util.concurrent.Executors
-
-@DataJpaTest(
-    properties = [
-        "spring.cache.type=none",
-        "spring.datasource.url=jdbc:h2:mem:testdb;MODE=MySQL;NON_KEYWORDS=VALUE"
-    ]
-)
-@Import(QueryDslConfig::class)
-@DisplayName("선물 신청번호 채번 테스트")
-class GiftApplicationNoGeneratorTest @Autowired constructor(
-    private val repository: GiftApplicationNoSequenceRepository,
-    private val categoryRepository: GiftCategoryRepository,
-    private val transactionManager: PlatformTransactionManager
-) {
-    @BeforeEach
-    fun setUp() {
-        repository.deleteAll()
-        categoryRepository.deleteAll()
-    }
-
-    @Test
-    @DisplayName("같은 카테고리와 날짜 신청번호를 순서대로 발급한다")
-    fun shouldGenerateSequentialApplicationNoByCategoryAndDate() {
-        val generator = GiftApplicationNoGenerator(repository, transactionManager)
-        val now = LocalDateTime.of(2026, 9, 29, 12, 0)
-        val category = saveCategory("100", "DOLL", "A")
-
-        val first = generator.generate(category, now)
-        val second = generator.generate(category, now)
-
-        assertEquals("A-1002609290001", first)
-        assertEquals("A-1002609290002", second)
-    }
-
-    @Test
-    @DisplayName("카테고리와 날짜가 다르면 sequence를 따로 발급한다")
-    fun shouldGenerateApplicationNoByCategoryAndDateIndependently() {
-        val generator = GiftApplicationNoGenerator(repository, transactionManager)
-        val doll = saveCategory("100", "DOLL", "A")
-        val food = saveCategory("200", "FOOD", "C")
-
-        val dollFirst = generator.generate(doll, LocalDateTime.of(2026, 9, 29, 12, 0))
-        val foodFirst = generator.generate(food, LocalDateTime.of(2026, 9, 29, 12, 0))
-        val dollNextDay = generator.generate(doll, LocalDateTime.of(2026, 9, 30, 12, 0))
-
-        assertEquals("A-1002609290001", dollFirst)
-        assertEquals("C-2002609290001", foodFirst)
-        assertEquals("A-1002609300001", dollNextDay)
-    }
-
-    @Test
-    @DisplayName("sequence가 9999를 초과하면 자리수를 늘린다")
-    fun shouldExpandSequenceDigitsAfter9999() {
-        val generator = GiftApplicationNoGenerator(repository, transactionManager)
-        val category = saveCategory("100", "DOLL", "A")
-        val now = LocalDateTime.of(2026, 9, 30, 12, 0)
-        repository.save(GiftApplicationNoSequence(categoryId = category.id!!, sequenceDate = "260930", lastSequence = 9999))
-
-        val applicationNo = generator.generate(category, now)
-
-        assertEquals("A-10026093010000", applicationNo)
-    }
-
-    @Test
-    @DisplayName("병렬 발급 결과는 모두 중복되지 않는다")
-    fun shouldGenerateUniqueApplicationNoConcurrently() {
-        val generator = GiftApplicationNoGenerator(repository, transactionManager)
-        val now = LocalDateTime.of(2026, 9, 29, 12, 0)
-        val category = saveCategory("100", "DOLL", "A")
-        val executor = Executors.newFixedThreadPool(4)
-
-        val applicationNos = try {
-            executor.invokeAll(
-                (1..10).map {
-                    Callable { generator.generate(category, now) }
-                }
-            ).map { it.get() }
-        } finally {
-            executor.shutdownNow()
-        }
-
-        assertEquals(10, applicationNos.toSet().size)
-        assertEquals("A-1002609290001", applicationNos.minOrNull())
-        assertEquals("A-1002609290010", applicationNos.maxOrNull())
-    }
-
-    private fun saveCategory(classificationNumber: String, categoryCode: String, receiptCode: String) =
-        categoryRepository.save(
-            GiftCategory(
-                classificationNumber = classificationNumber,
-                categoryCode = categoryCode,
-                name = "인형",
-                receiptCode = receiptCode,
-                representativeItem = "피규어"
-            )
-        )
-}
@@ -1,145 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.application
-
-import kr.co.vividnext.sodalive.fcm.FcmDeepLinkValue
-import kr.co.vividnext.sodalive.fcm.FcmEvent
-import kr.co.vividnext.sodalive.fcm.FcmEventType
-import kr.co.vividnext.sodalive.fcm.notification.PushNotificationCategory
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Test
-import org.mockito.ArgumentCaptor
-import org.mockito.Mockito
-import org.springframework.context.ApplicationEventPublisher
-
-class GiftPushServiceTest {
-    private val eventPublisher = Mockito.mock(ApplicationEventPublisher::class.java)
-    private val service = GiftPushService(eventPublisher)
-
-    @Test
-    fun shouldPublishTrackingDeadlineReminderToSender() {
-        service.sendTrackingDeadlineReminder(APPLICATION_NO, MEMBER_ID)
-
-        val event = capturePublishedEvent()
-        assertGiftEvent(event)
-        assertEquals("운송장 번호를 입력해 주세요", event.title)
-        assertEquals("24시간 이내에 운송장 번호를 등록해 주세요.\n기한 내 등록하지 않으면 신청이 자동 취소됩니다.", event.message)
-    }
-
-    @Test
-    fun shouldPublishRecipientAddressDeadlineReminderToRecipient() {
-        service.sendRecipientAddressDeadlineReminder(APPLICATION_NO, MEMBER_ID)
-
-        val event = capturePublishedEvent()
-        assertGiftEvent(event)
-        assertEquals("배송지 입력 기한이 1일 남았어요", event.title)
-        assertEquals("24시간 안에 배송지를 입력해 주세요.\n입력하지 않으면 선물은 반송되지 않고 폐기돼요", event.message)
-    }
-
-    @Test
-    fun shouldPublishAutoCanceledToSender() {
-        service.sendAutoCanceledToSender(APPLICATION_NO, MEMBER_ID)
-
-        val event = capturePublishedEvent()
-        assertGiftEvent(event)
-        assertEquals("선물 신청이 자동 취소됐어요", event.title)
-        assertEquals("신청 후 3일 이내에 운송장 번호가 등록되지 않아 신청이 취소됐어요.\n사용한 캔은 모두 환불되었습니다.", event.message)
-    }
-
-    @Test
-    fun shouldPublishTrackingRegisteredToRecipient() {
-        service.sendTrackingRegisteredToRecipient(APPLICATION_NO, MEMBER_ID)
-
-        val event = capturePublishedEvent()
-        assertGiftEvent(event)
-        assertEquals("팬이 보낸 선물이 있어요!", event.title)
-        assertEquals("7일 이내에 배송지를 입력해 주세요.\n기간이 지나면 선물을 받을 수 없어요", event.message)
-    }
-
-    @Test
-    fun shouldPublishArrivedAtMailboxToSender() {
-        service.sendArrivedAtMailboxToSender(APPLICATION_NO, MEMBER_ID)
-
-        val event = capturePublishedEvent()
-        assertGiftEvent(event)
-        assertEquals("선물이 사서함에 도착했어요", event.title)
-        assertEquals("보내주신 선물이 소다라이브 사서함에 도착했어요.\n안전하게 전달할 수 있도록 선물을 확인하고 있어요.", event.message)
-    }
-
-    @Test
-    fun shouldPublishArrivedAtMailboxToRecipient() {
-        service.sendArrivedAtMailboxToRecipient(APPLICATION_NO, MEMBER_ID)
-
-        val event = capturePublishedEvent()
-        assertGiftEvent(event)
-        assertEquals("선물이 사서함에 도착했어요", event.title)
-        assertEquals("팬이 보낸 선물을 검수하고 있어요.\n검수가 끝나면 다시 알려드릴게요", event.message)
-    }
-
-    @Test
-    fun shouldPublishInspectionCompletedToRecipient() {
-        service.sendInspectionCompleted(APPLICATION_NO, MEMBER_ID)
-
-        val event = capturePublishedEvent()
-        assertGiftEvent(event)
-        assertEquals("선물 검수가 완료됐어요", event.title)
-        assertEquals("확인된 선물을 빠른 시일 내에 입력하신 배송지로 보내드릴게요.", event.message)
-    }
-
-    @Test
-    fun shouldPublishUndeliverableToSender() {
-        service.sendUndeliverableToSender(APPLICATION_NO, MEMBER_ID)
-
-        val event = capturePublishedEvent()
-        assertGiftEvent(event)
-        assertEquals("선물을 전달할 수 없어요", event.title)
-        assertEquals("도착한 선물이 선물 접수 규격에 맞지 않아 크리에이터에게 전달할 수 없어요.\n자세한 사유는 신청 상세에서 확인해 주세요.", event.message)
-    }
-
-    @Test
-    fun shouldPublishUndeliverableToRecipient() {
-        service.sendUndeliverableToRecipient(APPLICATION_NO, MEMBER_ID)
-
-        val event = capturePublishedEvent()
-        assertGiftEvent(event)
-        assertEquals("전달할 수 없는 선물이 있어요", event.title)
-        assertEquals("검수 결과 선물 정책에 맞지 않아 해당 선물은 배송되지 않아요.\n자세한 사유를 확인해 주세요.", event.message)
-    }
-
-    @Test
-    fun shouldPublishDeliveredToSender() {
-        service.sendDeliveredToSender(APPLICATION_NO, MEMBER_ID)
-
-        val event = capturePublishedEvent()
-        assertGiftEvent(event)
-        assertEquals("선물이 전달됐어요", event.title)
-        assertEquals("보내주신 선물이 크리에이터에게 안전하게 전달됐어요.", event.message)
-    }
-
-    @Test
-    fun shouldPublishDeliveredToRecipient() {
-        service.sendDeliveredToRecipient(APPLICATION_NO, MEMBER_ID)
-
-        val event = capturePublishedEvent()
-        assertGiftEvent(event)
-        assertEquals("선물이 도착했어요!", event.title)
-        assertEquals("팬이 보낸 선물이 배송지에 도착했어요.\n지금 확인해 보세요.", event.message)
-    }
-
-    private fun assertGiftEvent(event: FcmEvent) {
-        assertEquals(FcmEventType.INDIVIDUAL, event.type)
-        assertEquals(PushNotificationCategory.GIFT, event.category)
-        assertEquals(FcmDeepLinkValue.GIFT_DETAIL, event.deepLinkValue)
-        assertEquals(APPLICATION_NO, event.deepLinkId)
-        assertEquals(listOf(MEMBER_ID), event.recipients)
-    }
-
-    private fun capturePublishedEvent(): FcmEvent {
-        val captor = ArgumentCaptor.forClass(FcmEvent::class.java)
-        Mockito.verify(eventPublisher).publishEvent(captor.capture())
-        return captor.value
-    }
-
-    private companion object {
-        const val APPLICATION_NO = "G20260929000001"
-        const val MEMBER_ID = 1L
-    }
-}
@@ -1,426 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.application
-
-import kr.co.vividnext.sodalive.common.SodaException
-import kr.co.vividnext.sodalive.configs.QueryDslConfig
-import kr.co.vividnext.sodalive.member.Member
-import kr.co.vividnext.sodalive.member.MemberRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.Gift
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategory
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftCategoryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDelivery
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftDeliveryRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftRepository
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftSizePrice
-import kr.co.vividnext.sodalive.v2.gift.adapter.out.persistence.GiftSizePriceRepository
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftDirection
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftListType
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftSize
-import kr.co.vividnext.sodalive.v2.gift.domain.GiftStatus
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Assertions.assertNotNull
-import org.junit.jupiter.api.Assertions.assertNull
-import org.junit.jupiter.api.Assertions.assertThrows
-import org.junit.jupiter.api.DisplayName
-import org.junit.jupiter.api.Test
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
-import org.springframework.context.annotation.Import
-import java.time.LocalDateTime
-
-@DataJpaTest(
-    properties = [
-        "spring.cache.type=none",
-        "spring.datasource.url=jdbc:h2:mem:gift-query;MODE=MySQL;NON_KEYWORDS=VALUE"
-    ]
-)
-@Import(QueryDslConfig::class)
-class GiftQueryServiceTest @Autowired constructor(
-    private val categoryRepository: GiftCategoryRepository,
-    private val sizePriceRepository: GiftSizePriceRepository,
-    private val giftRepository: GiftRepository,
-    private val deliveryRepository: GiftDeliveryRepository,
-    private val memberRepository: MemberRepository
-) {
-    @Test
-    fun `폼 옵션은 활성 카테고리와 활성 사이즈 가격만 반환한다`() {
-        val activeCategory = categoryRepository.save(giftCategory("100", "DOLL", "A", "인형", "피규어", true, true))
-        categoryRepository.save(giftCategory("200", "FOOD", "B", "간식", "쿠키", false, false))
-        sizePriceRepository.save(GiftSizePrice(GiftSize.SMALL, 100, 80, true))
-        sizePriceRepository.save(GiftSizePrice(GiftSize.MEDIUM, 150, 120, false))
-
-        val result = queryService().getFormOptions()
-
-        assertEquals(listOf(GiftSize.SMALL), result.sizes.map { it.sizeCode })
-        assertEquals(listOf(100), result.sizes.map { it.basePriceCan })
-        assertEquals(listOf(80), result.sizes.map { it.salePriceCan })
-        assertEquals(listOf(activeCategory.id), result.categories.map { it.categoryId })
-        assertEquals("인형/피규어", result.categories.single().name)
-        assertEquals(true, result.categories.single().requiresDamageWaiver)
-    }
-
-    @Test
-    @DisplayName("보낸 선물은 접수 직후 선물함에 노출된다")
-    fun shouldListReceivedGiftForSender() {
-        saveGift("G-SENT-RECEIVED", senderMemberId = MEMBER_ID, recipientMemberId = 2L, status = GiftStatus.RECEIVED)
-
-        val result = queryService().getGifts(
-            memberId = MEMBER_ID,
-            type = GiftListType.SENT,
-            page = 0,
-            size = 20
-        )
-
-        assertEquals(1L, result.totalCount)
-        assertEquals(1, result.items.size)
-        assertEquals("G-SENT-RECEIVED", result.items.single().applicationNo)
-        assertEquals(GiftDirection.SENT, result.items.single().direction)
-        assertEquals(GiftStatus.RECEIVED, result.items.single().status)
-        assertEquals(GiftStatus.RECEIVED.displayName, result.items.single().statusName)
-        assertEquals(80, result.items.single().priceCan)
-        assertEquals("인형", result.items.single().categoryName)
-        assertEquals("소형", result.items.single().sizeName)
-        assertNotNull(result.items.single().createdAt)
-    }
-
-    @Test
-    @DisplayName("받은 선물은 운송장 등록 이후 상태만 선물함에 노출된다")
-    fun shouldExcludeReceivedOnlyGiftAndListVisibleGiftForRecipient() {
-        saveGift("G-RECEIVED-HIDDEN", senderMemberId = 2L, recipientMemberId = MEMBER_ID, status = GiftStatus.RECEIVED)
-        saveGift(
-            "G-RECEIVED-VISIBLE",
-            senderMemberId = 3L,
-            recipientMemberId = MEMBER_ID,
-            status = GiftStatus.TRACKING_REGISTERED
-        )
-
-        val result = queryService().getGifts(
-            memberId = MEMBER_ID,
-            type = GiftListType.RECEIVED,
-            page = 0,
-            size = 20
-        )
-
-        assertEquals(1L, result.totalCount)
-        assertEquals(listOf("G-RECEIVED-VISIBLE"), result.items.map { it.applicationNo })
-        assertEquals(GiftDirection.RECEIVED, result.items.single().direction)
-    }
-
-    @Test
-    @DisplayName("전체 선물함은 보낸 선물과 노출 가능한 받은 선물을 방향과 함께 반환한다")
-    fun shouldListSentAndVisibleReceivedGiftsWithDirectionsForAll() {
-        saveGift("G-ALL-SENT", senderMemberId = MEMBER_ID, recipientMemberId = 2L, status = GiftStatus.CANCELED)
-        saveGift(
-            "G-ALL-RECEIVED",
-            senderMemberId = 3L,
-            recipientMemberId = MEMBER_ID,
-            status = GiftStatus.ARRIVED_AT_MAILBOX
-        )
-        saveGift("G-ALL-HIDDEN", senderMemberId = 4L, recipientMemberId = MEMBER_ID, status = GiftStatus.RECEIVED)
-
-        val result = queryService().getGifts(
-            memberId = MEMBER_ID,
-            type = GiftListType.ALL,
-            page = 0,
-            size = 20
-        )
-
-        assertEquals(2L, result.totalCount)
-        assertEquals(
-            mapOf("G-ALL-SENT" to GiftDirection.SENT, "G-ALL-RECEIVED" to GiftDirection.RECEIVED),
-            result.items.associate { it.applicationNo to it.direction }
-        )
-    }
-
-    @Test
-    @DisplayName("선물함 page와 size는 음수 또는 0이면 기본값으로 보정된다")
-    fun shouldNormalizeGiftListPageAndSize() {
-        saveGift("G-PAGING", senderMemberId = MEMBER_ID, recipientMemberId = 2L, status = GiftStatus.RECEIVED)
-
-        val result = queryService().getGifts(
-            memberId = MEMBER_ID,
-            type = GiftListType.SENT,
-            page = -1,
-            size = 0
-        )
-
-        assertEquals(0, result.page)
-        assertEquals(20, result.size)
-        assertEquals(false, result.hasNext)
-        assertEquals(listOf("G-PAGING"), result.items.map { it.applicationNo })
-    }
-
-    @Test
-    @DisplayName("발신자는 자신의 선물 상세와 발신자 정보만 조회한다")
-    fun shouldReturnSentGiftDetailWithoutRecipientAddress() {
-        val sender = saveMember("fan")
-        val recipient = saveMember("creator")
-        val gift = saveGift(
-            applicationNo = "G-SENT-DETAIL",
-            senderMemberId = sender.id!!,
-            recipientMemberId = recipient.id!!,
-            status = GiftStatus.RECEIVED
-        )
-        val delivery = saveDelivery(gift)
-        delivery.recipientName = "수신자"
-        delivery.recipientPhoneNumber = "01098765432"
-        delivery.recipientZipCode = "04524"
-        delivery.recipientAddress = "서울시 중구"
-        delivery.recipientAddressDetail = "202호"
-
-        val result = queryService().getGiftDetail(sender.id!!, gift.applicationNo)
-
-        assertEquals(GiftDirection.SENT, result.direction)
-        assertEquals(recipient.nickname, result.giftInfo.recipientCreatorNickname)
-        assertNull(result.giftInfo.senderNickname)
-        assertEquals("소형", result.giftInfo.sizeName)
-        assertEquals("인형", result.giftInfo.categoryName)
-        assertEquals(gift.applicationNo, result.giftInfo.applicationNo)
-        assertEquals(80, result.giftInfo.paidCan)
-        assertNull(result.giftInfo.tracking)
-        assertNull(result.giftInfo.shippingRequestedAt)
-        assertEquals("발신자", result.senderInfo?.name)
-        assertEquals("01012345678", result.senderInfo?.phoneNumber)
-        assertEquals("(06234) 서울시 강남구, 101동 1001호", result.senderInfo?.address)
-        assertNull(result.recipientAddress)
-        assertNull(result.mailbox)
-        assertEquals(true, result.trackingRequired)
-        assertEquals(false, result.recipientAddressRequired)
-        assertEquals(
-            listOf(
-                GiftStatus.RECEIVED,
-                GiftStatus.TRACKING_REGISTERED,
-                GiftStatus.ARRIVED_AT_MAILBOX,
-                GiftStatus.INSPECTION_COMPLETED,
-                GiftStatus.DELIVERED
-            ),
-            result.statusTimeline.map { it.status }
-        )
-        assertNotNull(result.statusTimeline[0].occurredAt)
-        assertNull(result.statusTimeline[1].occurredAt)
-    }
-
-    @Test
-    @DisplayName("수신자는 노출된 선물 상세에서 자신의 배송지와 발신자 닉네임만 조회한다")
-    fun shouldReturnReceivedGiftDetailWithoutSenderInformation() {
-        val sender = saveMember("fan")
-        val recipient = saveMember("creator")
-        val gift = saveGift(
-            applicationNo = "G-RECEIVED-DETAIL",
-            senderMemberId = sender.id!!,
-            recipientMemberId = recipient.id!!,
-            status = GiftStatus.TRACKING_REGISTERED
-        )
-        saveDelivery(gift).apply {
-            trackingRegisteredAt = NOW.plusHours(1)
-            recipientName = "수신자"
-            recipientPhoneNumber = "01098765432"
-            recipientZipCode = "04524"
-            recipientAddress = "서울시 중구"
-            recipientAddressDetail = "202호"
-        }
-
-        val result = queryService().getGiftDetail(recipient.id!!, gift.applicationNo)
-
-        assertEquals(GiftDirection.RECEIVED, result.direction)
-        assertNull(result.giftInfo.recipientCreatorNickname)
-        assertEquals(sender.nickname, result.giftInfo.senderNickname)
-        assertEquals("소형", result.giftInfo.sizeName)
-        assertEquals("인형", result.giftInfo.categoryName)
-        assertNull(result.giftInfo.applicationNo)
-        assertNull(result.giftInfo.paidCan)
-        assertNull(result.giftInfo.tracking)
-        assertNotNull(result.giftInfo.shippingRequestedAt)
-        assertNull(result.senderInfo)
-        assertEquals("수신자", result.recipientAddress?.name)
-        assertEquals("01098765432", result.recipientAddress?.phoneNumber)
-        assertEquals("(04524) 서울시 중구, 202호", result.recipientAddress?.address)
-        assertNull(result.mailbox)
-        assertEquals(false, result.trackingRequired)
-        assertEquals(false, result.recipientAddressRequired)
-        assertNotNull(result.statusTimeline[0].occurredAt)
-        assertEquals(NOW.plusHours(1), result.statusTimeline[1].occurredAt)
-        assertNull(result.statusTimeline[2].occurredAt)
-    }
-
-    @Test
-    @DisplayName("상세 조회는 수신자 노출 조건과 관계없는 회원 및 배송 정보 누락을 거부한다")
-    fun shouldRejectHiddenOrUnrelatedGiftDetailAndMissingDelivery() {
-        val sender = saveMember("fan")
-        val recipient = saveMember("creator")
-        val other = saveMember("other")
-        val hiddenGift = saveGift(
-            applicationNo = "G-HIDDEN-DETAIL",
-            senderMemberId = sender.id!!,
-            recipientMemberId = recipient.id!!,
-            status = GiftStatus.RECEIVED
-        )
-        saveDelivery(hiddenGift)
-        val visibleGift = saveGift(
-            applicationNo = "G-VISIBLE-DETAIL",
-            senderMemberId = sender.id!!,
-            recipientMemberId = recipient.id!!,
-            status = GiftStatus.TRACKING_REGISTERED
-        )
-        saveDelivery(visibleGift)
-        val missingDeliveryGift = saveGift(
-            applicationNo = "G-MISSING-DELIVERY",
-            senderMemberId = sender.id!!,
-            recipientMemberId = recipient.id!!,
-            status = GiftStatus.RECEIVED
-        )
-        val service = queryService()
-
-        val hiddenException = assertThrows(SodaException::class.java) {
-            service.getGiftDetail(recipient.id!!, hiddenGift.applicationNo)
-        }
-        val unrelatedException = assertThrows(SodaException::class.java) {
-            service.getGiftDetail(other.id!!, visibleGift.applicationNo)
-        }
-        val missingDeliveryException = assertThrows(SodaException::class.java) {
-            service.getGiftDetail(sender.id!!, missingDeliveryGift.applicationNo)
-        }
-
-        assertEquals("common.error.invalid_request", hiddenException.messageKey)
-        assertEquals("common.error.invalid_request", unrelatedException.messageKey)
-        assertEquals("common.error.invalid_request", missingDeliveryException.messageKey)
-    }
-
-    @Test
-    @DisplayName("수신자 배송지 입력 필요 여부는 미입력인 진행 상태에서만 참이다")
-    fun shouldRequireRecipientAddressOnlyForNonTerminalReceivedGift() {
-        val sender = saveMember("fan")
-        val recipient = saveMember("creator")
-        val pendingGift = saveGift(
-            applicationNo = "G-ADDRESS-PENDING",
-            senderMemberId = sender.id!!,
-            recipientMemberId = recipient.id!!,
-            status = GiftStatus.TRACKING_REGISTERED
-        )
-        saveDelivery(pendingGift).trackingRegisteredAt = NOW
-        val terminalGift = saveGift(
-            applicationNo = "G-ADDRESS-TERMINAL",
-            senderMemberId = sender.id!!,
-            recipientMemberId = recipient.id!!,
-            status = GiftStatus.UNDELIVERABLE
-        )
-        saveDelivery(terminalGift).apply {
-            trackingRegisteredAt = NOW
-            undeliverableAt = NOW.plusHours(1)
-            undeliverableReason = "배송지 미입력 기한 초과"
-        }
-        val service = queryService()
-
-        val pendingResult = service.getGiftDetail(recipient.id!!, pendingGift.applicationNo)
-        val terminalResult = service.getGiftDetail(recipient.id!!, terminalGift.applicationNo)
-
-        assertEquals(true, pendingResult.recipientAddressRequired)
-        assertNull(pendingResult.recipientAddress)
-        assertEquals(false, terminalResult.recipientAddressRequired)
-    }
-
-    @Test
-    @DisplayName("취소와 전달 불가 상세는 정상 진행 타임라인과 종료 정보를 함께 반환한다")
-    fun shouldReturnTerminalInformationWithNormalProgressTimeline() {
-        val sender = saveMember("fan")
-        val recipient = saveMember("creator")
-        val canceledGift = saveGift(
-            applicationNo = "G-CANCELED-DETAIL",
-            senderMemberId = sender.id!!,
-            recipientMemberId = recipient.id!!,
-            status = GiftStatus.CANCELED
-        )
-        saveDelivery(canceledGift).canceledAt = NOW.plusHours(1)
-        val undeliverableGift = saveGift(
-            applicationNo = "G-UNDELIVERABLE-X",
-            senderMemberId = sender.id!!,
-            recipientMemberId = recipient.id!!,
-            status = GiftStatus.UNDELIVERABLE
-        )
-        saveDelivery(undeliverableGift).apply {
-            trackingRegisteredAt = NOW.plusHours(1)
-            arrivedAtMailboxAt = NOW.plusHours(2)
-            undeliverableAt = NOW.plusHours(3)
-            undeliverableReason = "검수 실패"
-        }
-        val service = queryService()
-
-        val canceledResult = service.getGiftDetail(sender.id!!, canceledGift.applicationNo)
-        val undeliverableResult = service.getGiftDetail(sender.id!!, undeliverableGift.applicationNo)
-
-        assertEquals(NOW.plusHours(1), canceledResult.delivery.canceledAt)
-        assertNull(canceledResult.statusTimeline[1].occurredAt)
-        assertEquals(NOW.plusHours(1), undeliverableResult.statusTimeline[1].occurredAt)
-        assertEquals(NOW.plusHours(2), undeliverableResult.statusTimeline[2].occurredAt)
-        assertNull(undeliverableResult.statusTimeline[3].occurredAt)
-        assertEquals(NOW.plusHours(3), undeliverableResult.delivery.undeliverableAt)
-        assertEquals("검수 실패", undeliverableResult.delivery.undeliverableReason)
-    }
-
-    private fun saveGift(
-        applicationNo: String,
-        senderMemberId: Long,
-        recipientMemberId: Long,
-        status: GiftStatus
-    ) = giftRepository.save(
-        Gift(
-            applicationNo = applicationNo,
-            senderMemberId = senderMemberId,
-            recipientMemberId = recipientMemberId,
-            status = status,
-            sizeCode = GiftSize.SMALL,
-            categoryId = 1L,
-            categoryNameSnapshot = "인형",
-            salePriceCan = 80,
-            canUsageId = 1L,
-            senderTermsAgreed = true,
-            senderPrivacyAgreed = true,
-            senderTermsAgreedAt = NOW,
-            senderPrivacyAgreedAt = NOW
-        )
-    )
-
-    private fun saveMember(nickname: String) = memberRepository.save(Member(password = "password", nickname = nickname))
-
-    private fun giftCategory(
-        classificationNumber: String,
-        categoryCode: String,
-        receiptCode: String,
-        name: String,
-        representativeItem: String,
-        requiresDamageWaiver: Boolean,
-        isActive: Boolean
-    ) = GiftCategory(
-        classificationNumber = classificationNumber,
-        categoryCode = categoryCode,
-        name = name,
-        receiptCode = receiptCode,
-        representativeItem = representativeItem,
-        requiresDamageWaiver = requiresDamageWaiver,
-        isActive = isActive
-    )
-
-    private fun saveDelivery(gift: Gift) = deliveryRepository.save(
-        GiftDelivery(
-            giftId = gift.id!!,
-            senderName = "발신자",
-            senderPhoneNumber = "01012345678",
-            senderZipCode = "06234",
-            senderAddress = "서울시 강남구",
-            senderAddressDetail = "101동 1001호",
-            trackingDeadlineAt = NOW.plusDays(3)
-        )
-    )
-
-    private fun queryService() = GiftQueryService(
-        categoryRepository,
-        sizePriceRepository,
-        giftRepository,
-        deliveryRepository,
-        memberRepository
-    )
-
-    private companion object {
-        const val MEMBER_ID = 1L
-        val NOW: LocalDateTime = LocalDateTime.of(2026, 9, 29, 12, 0)
-    }
-}
@@ -1,19 +0,0 @@
-package kr.co.vividnext.sodalive.v2.gift.domain
-
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.DisplayName
-import org.junit.jupiter.api.Test
-
-class GiftStatusTest {
-    @Test
-    @DisplayName("선물 상태 표시명은 한글 띄어쓰기를 통일한다")
-    fun shouldUseConsistentKoreanSpacingForDisplayNames() {
-        assertEquals("접수 완료", GiftStatus.RECEIVED.displayName)
-        assertEquals("발송 확인", GiftStatus.TRACKING_REGISTERED.displayName)
-        assertEquals("사서함 도착", GiftStatus.ARRIVED_AT_MAILBOX.displayName)
-        assertEquals("검수 완료", GiftStatus.INSPECTION_COMPLETED.displayName)
-        assertEquals("전달 완료", GiftStatus.DELIVERED.displayName)
-        assertEquals("전달 불가", GiftStatus.UNDELIVERABLE.displayName)
-        assertEquals("신청 취소", GiftStatus.CANCELED.displayName)
-    }
-}