Merge branch 'develop' into feature/changeConstructor

* feat: 결제내역 상세 조회

alternatedId 컬럼추가
GUEST -> USER 권한명칭변경
User Entity: isDeleted, deletedAt
closed #53, #61, #62, #63

* refactor: 프로퍼티 권한 private -> protected 변경

closed #60

* refactor: access Token 시간 변경

closed #65

* refactor: 에러코드 부분 수정

* feat: id 포함 생성자 추가

README.md

@@ -1,5 +1,5 @@
 # 🍿 Ticketing
-영화 예매 서비스
+영화 예매 사이트를 대용량 트래픽에 대응할 수 있도록 설계.
 
 <br/>
 
@@ -8,32 +8,58 @@
 - 기획 및 설계 : 22.04.13 ~ 
 - 프로젝트 구현 :   
 
+<br/>
 
-<br/><br/>
+## 🎯 프로젝트 주요 관심사
+- OOP(객체 지향 프로그래밍)의 장점을 최대한 활용
+- 테스트 코드를 통한 믿을 수 있는 코드 작성
+- 대용량 트래픽을 고려한 확장 가능한 설계 및 성능 튜닝
+- 코드리뷰를 통해 코드 품질 향상
+- 코드 컨벤션 준수하여 코드 통일성 유지
 
-## 🎯 프로젝트 목표
+<br/>
 
+## 🛠 기술스택
+- Java 11
+- Spring Boot 2.6.7 (당시 최신 GA 버전)
+- Gradle Kotlin DSL
+- Spring Security
+- Junit 5
+- Hibernate / SpringJPA
+- MySQL 8.0
+- Redis
 
-<br/><br/>
+<br/>
+
+## Wiki
+- [Git Branch 전략](https://github.com/f-lab-edu/Ticketing/wiki#-git-branch-%EC%A0%84%EB%9E%B5)
+- [Code Convention](https://github.com/f-lab-edu/Ticketing/wiki#-code-convention)
+- [패키지 구조](https://github.com/f-lab-edu/Ticketing/wiki#-%ED%8C%A8%ED%82%A4%EC%A7%80-%EA%B5%AC%EC%A1%B0)
+- [Use Case](https://github.com/f-lab-edu/Ticketing/wiki/Use-Case)
+- [Prototype](https://github.com/f-lab-edu/Ticketing/wiki/Prototype)
+
+<br/>
 
 ## 🧩 ERD
 
 ``` mermaid
 erDiagram
-    MOVIE ||--o{ MOVIE_TIMES : ""
+    MOVIE ||--o{ MOVIE_TIME : ""
     MOVIE {
         bigint id PK "영화 ID"
         varchar title "영화제목"
         int running_time "러닝타임"
+        datetime deleted_at "삭제일시"
         datetime created_at "등록일시"
         datetime updated_at "수정일시"
     }
-    THEATER ||--o{ MOVIE_TIMES : ""
+    THEATER ||--o{ MOVIE_TIME : ""
     THEATER ||--|{ SEAT : ""
     THEATER {
         bigint id PK "상영관 ID"
         int theater_number "상영관 번호"
         int seat_count "좌석수"
+        datetime deleted_at "삭제일시"
         datetime created_at "등록일시"
         datetime updated_at "수정일시"
     }
@@ -43,56 +69,58 @@ erDiagram
         bigint theater_id FK "상영관 ID"
         int column "열"
         int row "행"
+        datetime deleted_at "삭제일시"
         datetime created_at "등록일시"
         datetime updated_at "수정일시"
     }
-    MOVIE_TIMES ||--o{ TICKET : ""
-    MOVIE_TIMES {
+    MOVIE_TIME ||--o{ TICKET : ""
+    MOVIE_TIME {
         bigint id PK "상영시간표 ID"
         bigint movie_id FK "영화 ID"
         bigint theater_id FK "상영관 ID"
-        date running_date "상영 날짜"
         int round "회차"
         time start_at "시작 시간"
         time end_at "종료 시간"
+        datetime deleted_at "삭제일시"
         datetime created_at "등록일시"
         datetime updated_at "수정일시"
     }
     TICKET {
         bigint id PK "티켓 ID"
         bigint seat_id FK "좌석 ID"
-        bigint movie_times_id FK "상영시간표 ID"
-        bigint payment_id FK "결제 ID"
+        bigint movie_time_id FK "상영시간표 ID"
+        bigint payment_id "결제 ID"
         varchar status "상태 - 구매가능/예약진행중/판매완료"
         int ticket_price "가격"
+        datetime deleted_at "삭제일시"
         datetime created_at "등록일시"
         datetime updated_at "수정일시"
     }
     TICKET }|--|| PAYMENT : ""
     PAYMENT {
         bigint id PK "결제 ID"
-        bigint user_id FK "유저ID"
+        bigint user_alternate_id "유저 대체ID"
+        varchar movie_title "영화제목"
         varchar type "결제 타입 - 예) 네이버페이, 카카오페이"
         varchar status "상태 - 완료/환불/실패"
         varchar failed_message "실패사유 - 컬럼명을 알아보기 쉬운가?"
         varchar payment_number "예매번호"
         int total_price "결제 금액"
+        datetime deleted_at "삭제일시"
         datetime created_at "결제일시"
         datetime updated_at "수정일시"
     }
     USER ||--o{ PAYMENT : ""
     USER {
         bigint id "회원"
+        bigint alternate_id "대체ID"
         varchar name "이름"
         varchar email "이메일"
         varchar password "비밀번호"
         varchar grade "등급 - 고객/임직원"
         varchar phone "휴대폰 번호"
-        boolean is_deleted "탈퇴여부"
         datetime deleted_at "탈퇴일시"
         datetime created_at "가입일시"
         datetime updated_at "수정일시"
     }
 ```
-
-<br/><br/>

server/build.gradle.kts

@@ -23,8 +23,6 @@ repositories {
 	mavenCentral()
 }
 
-
-
 dependencies {
 	implementation("org.springframework.boot:spring-boot-starter-data-jpa")
 	implementation("org.springframework.boot:spring-boot-starter-security")
@@ -32,14 +30,15 @@ dependencies {
 	implementation("org.springframework.boot:spring-boot-starter-web")
 	implementation("org.springframework.boot:spring-boot-starter-actuator")
 	implementation("org.springframework.boot:spring-boot-starter-log4j2")
-	implementation("org.projectlombok:lombok:1.18.20")
+	implementation("org.projectlombok:lombok:1.18.24")
 	implementation("io.springfox:springfox-boot-starter:3.0.0")
 	implementation("io.springfox:springfox-swagger-ui:3.0.0")
 	implementation("com.github.ulisesbocchio:jasypt-spring-boot-starter:3.0.4")
-	implementation("com.lmax:disruptor:3.4.2")
-	implementation("io.jsonwebtoken:jjwt-api:0.11.2")
+	implementation("com.lmax:disruptor:3.4.4")
+	implementation("io.jsonwebtoken:jjwt-api:0.11.5")
 	implementation("com.googlecode.json-simple:json-simple:1.1.1")
 	implementation("org.springframework.boot:spring-boot-starter-data-redis")
+	implementation("com.google.code.findbugs:jsr305:3.0.2")
 
 	modules {
 		module("org.springframework.boot:spring-boot-starter-logging") {
@@ -47,18 +46,14 @@ dependencies {
 		}
 	}
 
-	testImplementation("org.springframework.boot:spring-boot-starter-test")
-	testImplementation("org.springframework.security:spring-security-test")
-	testImplementation("org.junit.jupiter:junit-jupiter-api:5.8.1")
-
 	compileOnly("org.projectlombok:lombok")
 	runtimeOnly("mysql:mysql-connector-java")
-	runtimeOnly("io.jsonwebtoken:jjwt-impl:0.11.2")
-	runtimeOnly("io.jsonwebtoken:jjwt-jackson:0.11.2")
+	runtimeOnly("io.jsonwebtoken:jjwt-impl:0.11.5")
+	runtimeOnly("io.jsonwebtoken:jjwt-jackson:0.11.5")
 	annotationProcessor("org.projectlombok:lombok")
 	annotationProcessor("org.springframework.boot:spring-boot-configuration-processor")
 
-	testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.8.1")
+	testImplementation("org.junit.jupiter:junit-jupiter-api:5.8.1")
 	testImplementation("org.springframework.boot:spring-boot-starter-test")
 	testImplementation("org.springframework.security:spring-security-test")
 }
@@ -66,3 +61,28 @@ dependencies {
 tasks.withType<Test> {
 	useJUnitPlatform()
 }
+
+sourceSets {
+	create("intTest") {
+		compileClasspath += sourceSets.main.get().output
+		runtimeClasspath += sourceSets.main.get().output
+	}
+}
+
+val intTestImplementation by configurations.getting {
+	extendsFrom(configurations.implementation.get())
+}
+
+configurations["intTestRuntimeOnly"].extendsFrom(configurations.runtimeOnly.get())
+configurations["intTestImplementation"].extendsFrom(configurations.testImplementation.get())
+
+val integrationTest = task<Test>("integrationTest") {
+	description = "Runs integration tests."
+	group = "verification"
+
+	testClassesDirs = sourceSets["intTest"].output.classesDirs
+	classpath = sourceSets["intTest"].runtimeClasspath
+	shouldRunAfter("test")
+}
+
+tasks.check { dependsOn(integrationTest) }

server/src/intTest/java/com/ticketing/server/movie/domain/MovieTest.java

@@ -0,0 +1,5 @@
+package com.ticketing.server.movie.domain;
+
+public class MovieTest {
+
+}

server/src/intTest/java/com/ticketing/server/movie/domain/repository/MovieRepositoryTest.java

@@ -30,7 +30,7 @@ public class MovieRepositoryTest {
     @DisplayName("Movie Repository Test - saving movie")
     void shouldAbleToSaveMovie() {
         // given
-        Movie movie = new Movie("범죄도시 2", 106);
+        Movie movie = new Movie("범죄도시 2", 106L);
 
         // when
         Movie savedMovie = movieRepository.save(movie);

server/src/intTest/java/com/ticketing/server/movie/domain/repository/TheaterRepositoryTest.java

@@ -20,7 +20,7 @@ public class TheaterRepositoryTest {
     @DisplayName("Theater Repository Test - saving theater")
     void ShouldAbleToSaveTheater() {
         // given
-        Theater theater = new Theater(1, 100);
+        Theater theater = new Theater(1);
 
         // when
         Theater savedTheater = theaterRepository.save(theater);

server/src/intTest/java/com/ticketing/server/user/application/AuthControllerTest.java

@@ -31,6 +31,7 @@ class AuthControllerTest {
 
 	private static final String LOGIN_URL = "/api/auth/token";
 	private static final String REGISTER_URL = "/api/users";
+	private static final String USER_EMAIL = "ticketing@gmail.com";
 
 	@Autowired
 	WebApplicationContext context;
@@ -53,7 +54,7 @@ class AuthControllerTest {
 	@DisplayName("로그인 인증 성공")
 	void loginSuccess() throws Exception {
 		// given
-		LoginRequest request = new LoginRequest("ticketing@gmail.com", "qwe123");
+		LoginRequest request = new LoginRequest(USER_EMAIL, "qwe123");
 
 		// when
 		ResultActions actions = mvc.perform(post(LOGIN_URL)
@@ -69,7 +70,7 @@ class AuthControllerTest {
 	@DisplayName("로그인 패스워드 인증 실패")
 	void loginPasswordFail() throws Exception {
 		// given
-		LoginRequest request = new LoginRequest("ticketing@gmail.com", "qwe1234");
+		LoginRequest request = new LoginRequest(USER_EMAIL, "qwe1234");
 
 		// when
 		ResultActions actions = mvc.perform(post(LOGIN_URL)
@@ -81,10 +82,6 @@ class AuthControllerTest {
 			.andExpect(status().isUnauthorized());
 	}
 
-	private String asJsonString(Object object) throws JsonProcessingException {
-		return objectMapper.writeValueAsString(object);
-	}
-
 	@BeforeEach
 	void init() throws Exception {
 		mvc = MockMvcBuilders
@@ -92,7 +89,7 @@ class AuthControllerTest {
 			.apply(springSecurity())
 			.build();
 
-		SignUpRequest signUpRequest = new SignUpRequest("ticketing", "ticketing@gmail.com", "qwe123", "010-2240-7920");
+		SignUpRequest signUpRequest = new SignUpRequest("ticketing", USER_EMAIL, "qwe123", "010-1234-5678");
 
 		mvc.perform(post(REGISTER_URL)
 			.content(asJsonString(signUpRequest))
@@ -104,4 +101,8 @@ class AuthControllerTest {
 		refreshRedisRepository.deleteAll();
 	}
 
+	private String asJsonString(Object object) throws JsonProcessingException {
+		return objectMapper.writeValueAsString(object);
+	}
+
 }

server/src/intTest/java/com/ticketing/server/user/application/UserControllerTest.java

@@ -0,0 +1,7 @@
+package com.ticketing.server.user.application;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class UserControllerTest {
+
+}

server/src/intTest/resources/application.yml

@@ -0,0 +1,37 @@
+spring:
+  datasource:
+    url: jdbc:mysql://localhost:3306/ticketing_test?serverTimezone=Asia/Seoul&characterEncoding=UTF-8
+    username: ENC(LowN1n4w0Ep/DqLD8+q5Bq6AXM4b8e3V)
+    password: ENC(OMvGcpZLpggFTiGNkqNe66Zq/SmJXF6o)
+    driver-class-name: com.mysql.cj.jdbc.Driver
+  redis:
+    host: localhost
+    port: 6379
+
+  jpa:
+    properties:
+      hibernate:
+        show_sql: true
+        format_sql: true
+    hibernate:
+      ddl-auto: create
+
+  mvc:
+    pathmatch:
+      matching-strategy: ant_path_matcher
+
+jasypt:
+  encryptor:
+    bean: jasyptStringEncryptor
+
+jwt:
+  access-header: Authorization
+  refresh-header: REFRESH_TOKEN
+  prefix: Bearer
+  secret-key: Zi1sYWItdGlja2V0aW5nLXByb2plY3Qtc3ByaW5nLWJvb3Qtc2VjdXJpdHktand0LXNlY3JldC1rZXktZi1sYWItdGlja2V0aW5nLXByb2plY3Qtc3ByaW5nLWJvb3Qtc2VjdXJpdHktand0LXNlY3JldC1rZXkK
+  access-token-validity-in-seconds: 60
+  refresh-token-validity-in-seconds: 259200
+
+tmdb:
+  api-key: 0d1503b6dcbfe1c514299b5564c649b8
+  read-access-token: eyJhbGciOiJIUzI1NiJ9.eyJhdWQiOiIwZDE1MDNiNmRjYmZlMWM1MTQyOTliNTU2NGM2NDliOCIsInN1YiI6IjYyOWYwODRlNzI2ZmIxMTA2NDA4MjI2NCIsInNjb3BlcyI6WyJhcGlfcmVhZCJdLCJ2ZXJzaW9uIjoxfQ.rs8KZea8QLyashILiggWFx2s46lgUtzo-xSWoDgE58A

server/src/main/java/com/ticketing/server/global/dto/repository/AbstractEntity.java

@@ -19,15 +19,15 @@ public abstract class AbstractEntity {
 
 	@Id
 	@GeneratedValue(strategy = GenerationType.IDENTITY)
-	private Long id;
+	protected Long id;
 
 	@Column(nullable = false, updatable = false)
 	@CreatedDate
-	private LocalDateTime createdAt;
+	protected LocalDateTime createdAt;
 
 	@LastModifiedDate
-	private LocalDateTime updatedAt;
+	protected LocalDateTime updatedAt;
 
-	private LocalDateTime deletedAt;
+	protected LocalDateTime deletedAt;
 
 }

server/src/main/java/com/ticketing/server/global/exception/ErrorCode.java

@@ -2,6 +2,7 @@ package com.ticketing.server.global.exception;
 
 import static org.springframework.http.HttpStatus.BAD_REQUEST;
 import static org.springframework.http.HttpStatus.CONFLICT;
+import static org.springframework.http.HttpStatus.FORBIDDEN;
 import static org.springframework.http.HttpStatus.NOT_FOUND;
 
 import lombok.AllArgsConstructor;
@@ -16,16 +17,85 @@ public enum ErrorCode {
 	MISMATCH_PASSWORD(BAD_REQUEST, "비밀번호가 일치하지 않습니다."),
 	TOKEN_TYPE(BAD_REQUEST, "토큰 타입이 올바르지 않습니다."),
 	UNAVAILABLE_REFRESH_TOKEN(BAD_REQUEST, "사용할 수 없는 토큰 입니다."),
+	UNABLE_CHANGE_GRADE(BAD_REQUEST, "동일한 등급으로 변경할 수 없습니다."),
+
+	/* 403 FORBIDDEN : 접근 권한 제한 */
+	VALID_USER_ID(FORBIDDEN, "해당 정보에 접근 권한이 존재하지 않습니다."),
 
 	/* 404 NOT_FOUND : Resource 를 찾을 수 없음 */
+	USER_NOT_FOUND(NOT_FOUND, "해당 유저 정보를 찾을 수 없습니다."),
 	EMAIL_NOT_FOUND(NOT_FOUND, "해당 이메일을 찾을 수 없습니다."),
+	MOVIE_NOT_FOUND(NOT_FOUND, "해당 제목의 영화를 찾을 수 없습니다."),
 	REFRESH_TOKEN_NOT_FOUND(NOT_FOUND, "리프레쉬 토큰을 찾을 수 없습니다."),
+	PAYMENT_ID_NOT_FOUND(NOT_FOUND, "결제정보를 찾을 수 없습니다."),
 
 	/* 409 CONFLICT : Resource 의 현재 상태와 충돌. 보통 중복된 데이터 존재 */
 	DUPLICATE_EMAIL(CONFLICT, "이메일이 이미 존재합니다."),
+	DUPLICATE_PAYMENT(CONFLICT, "해당 좌석은 현재 판매된 좌석입니다."),
+	DUPLICATE_MOVIE(CONFLICT, "해당 영화 정보가 이미 존재합니다."),
 	DELETED_EMAIL(CONFLICT, "이미 삭제된 이메일 입니다.");
 
 	private final HttpStatus httpStatus;
 	private final String detail;
 
+	/* 400 BAD_REQUEST : 잘못된 요청 */
+	public static TicketingException throwMismatchPassword() {
+		throw new TicketingException(MISMATCH_PASSWORD);
+	}
+
+	public static TicketingException throwTokenType() {
+		throw new TicketingException(TOKEN_TYPE);
+	}
+
+	public static TicketingException throwUnavailableRefreshToken() {
+		throw new TicketingException(UNAVAILABLE_REFRESH_TOKEN);
+	}
+
+	public static TicketingException throwUnableChangeGrade() {
+		throw new TicketingException(UNABLE_CHANGE_GRADE);
+	}
+
+	/* 403 FORBIDDEN : 접근 권한 제한 */
+	public static TicketingException throwValidUserId() {
+		throw new TicketingException(VALID_USER_ID);
+	}
+
+	/* 404 NOT_FOUND : Resource 를 찾을 수 없음 */
+	public static TicketingException throwUserNotFound() {
+		throw new TicketingException(USER_NOT_FOUND);
+	}
+
+	public static TicketingException throwEmailNotFound() {
+		throw new TicketingException(EMAIL_NOT_FOUND);
+	}
+
+	public static TicketingException throwMovieNotFound() {
+		throw new TicketingException(MOVIE_NOT_FOUND);
+	}
+
+	public static TicketingException throwRefreshTokenNotFound() {
+		throw new TicketingException(REFRESH_TOKEN_NOT_FOUND);
+	}
+
+	public static TicketingException throwPaymentIdNotFound() {
+		throw new TicketingException(PAYMENT_ID_NOT_FOUND);
+	}
+
+	/* 409 CONFLICT : Resource 의 현재 상태와 충돌. 보통 중복된 데이터 존재 */
+	public static TicketingException throwDuplicateEmail() {
+		throw new TicketingException(DUPLICATE_EMAIL);
+	}
+
+	public static TicketingException throwDuplicatePayment() {
+		throw new TicketingException(DUPLICATE_PAYMENT);
+	}
+
+	public static TicketingException throwDuplicateMovie() {
+		throw new TicketingException(DUPLICATE_MOVIE);
+	}
+
+	public static TicketingException throwDeletedEmail() {
+		throw new TicketingException(DELETED_EMAIL);
+	}
+
 }

server/src/main/java/com/ticketing/server/global/exception/GlobalExceptionHandler.java

@@ -9,6 +9,7 @@ import static org.springframework.http.HttpStatus.UNAUTHORIZED;
 import static org.springframework.http.HttpStatus.UNSUPPORTED_MEDIA_TYPE;
 
 import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
@@ -53,7 +54,8 @@ public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
 
 		List<String> errors = generateErrors(ex);
 		ErrorResponse response = new ErrorResponse(BAD_REQUEST, ex.getLocalizedMessage(), errors);
-		return handleExceptionInternal(ex, response, headers, response.getStatus(), request);
+
+		return ResponseEntity.status(response.getStatus()).headers(headers).body(response);
 	}
 
 	/***
@@ -66,7 +68,7 @@ public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
 
 		List<String> errors = generateErrors(ex);
 		ErrorResponse response = new ErrorResponse(BAD_REQUEST, ex.getLocalizedMessage(), errors);
-		return handleExceptionInternal(ex, response, headers, response.getStatus(), request);
+		return ResponseEntity.status(response.getStatus()).headers(headers).body(response);
 	}
 
 	/**
@@ -238,7 +240,7 @@ public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
 		List<ObjectError> allErrors = ex.getBindingResult().getAllErrors();
 
 		for (ObjectError error : allErrors) {
-			errors.add(((FieldError) error).getField() + ": " + error.getDefaultMessage());
+			errors.add(error.getDefaultMessage());
 		}
 		return errors;
 	}

server/src/main/java/com/ticketing/server/global/security/WebSecurityConfig.java

@@ -53,7 +53,8 @@ public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
 			.antMatchers(HttpMethod.POST, "/api/auth/token").permitAll()
 			.antMatchers(HttpMethod.POST, "/api/auth/refresh").permitAll()
 			.antMatchers(HttpMethod.POST, "/api/users").permitAll()
-			.antMatchers("/api/movies/**").permitAll()
+			.antMatchers(HttpMethod.GET,"/api/movies").permitAll()
+			.antMatchers("/api/movieTimes/**").permitAll()
 			.antMatchers("/l7check").permitAll()
 			.antMatchers("/actuator/**").permitAll()
 			.antMatchers("/api/v3/", "/swagger-ui/**", "/swagger/", "/swagger-resources/**", "/v3/api-docs").permitAll()

server/src/main/java/com/ticketing/server/global/security/jwt/JwtProvider.java

@@ -1,6 +1,6 @@
 package com.ticketing.server.global.security.jwt;
 
-import com.ticketing.server.user.application.response.TokenDto;
+import com.ticketing.server.user.service.dto.TokenDTO;
 import io.jsonwebtoken.Claims;
 import io.jsonwebtoken.Jwts;
 import io.jsonwebtoken.SignatureAlgorithm;
@@ -42,12 +42,12 @@ public class JwtProvider {
 		this.refreshTokenValidityInMilliseconds = jwtProperties.getRefreshTokenValidityInSeconds() * 1000L;
 	}
 
-	public TokenDto generateTokenDto(Authentication authentication) {
+	public TokenDTO generateTokenDto(Authentication authentication) {
 		String accessToken = createAccessToken(authentication);
 		String refreshToken = createRefreshToken(authentication);
 		long expiresIn = accessTokenValidityInMilliseconds / 1000L;
 
-		return TokenDto.of(accessToken, refreshToken, prefix, expiresIn);
+		return new TokenDTO(accessToken, refreshToken, prefix, expiresIn);
 	}
 
 	private String createAccessToken(Authentication authentication) {

server/src/main/java/com/ticketing/server/global/security/jwt/handle/JwtAuthenticationEntryPoint.java

@@ -3,7 +3,6 @@ package com.ticketing.server.global.security.jwt.handle;
 import java.io.IOException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.security.core.AuthenticationException;
 import org.springframework.security.web.AuthenticationEntryPoint;
@@ -23,4 +22,5 @@ public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {
 	public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException {
 		resolver.resolveException(request, response, null, authException);
 	}
+
 }

server/src/main/java/com/ticketing/server/global/validator/constraints/FieldsValueNotMatch.java

@@ -15,7 +15,7 @@ import javax.validation.Payload;
 @Documented
 public @interface FieldsValueNotMatch {
 
-	String message();
+	String message() default "validation.password.not.change";
 
 	String field();
 

server/src/main/java/com/ticketing/server/movie/application/MovieController.java

@@ -1,14 +1,20 @@
 package com.ticketing.server.movie.application;
 
+import com.ticketing.server.movie.application.request.MovieRegisterRequest;
 import com.ticketing.server.movie.application.response.MovieListResponse;
+import com.ticketing.server.movie.application.response.MovieTitleResponse;
 import com.ticketing.server.movie.service.interfaces.MovieService;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
+import javax.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.annotation.Secured;
 import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
@@ -19,12 +25,29 @@ import org.springframework.web.bind.annotation.RestController;
 @Slf4j
 public class MovieController {
 
-    private final MovieService movieService;
+	private final MovieService movieService;
 
-    @GetMapping()
-    @ApiOperation(value = "영화 목록 조회")
-    public ResponseEntity<MovieListResponse> getMovies() {
-        return ResponseEntity.status(HttpStatus.OK).body(MovieListResponse.from(movieService.getMovies()));
-    }
+	@PostMapping()
+	@ApiOperation(value = "영화 정보 등록")
+	@Secured("ROLE_STAFF")
+	public ResponseEntity<MovieTitleResponse> registerMovie(@RequestBody @Valid MovieRegisterRequest request) {
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(
+				MovieTitleResponse.from(
+					movieService.registerMovie(request.toMovieRegisterDTO())
+				)
+			);
+	}
+
+	@GetMapping()
+	@ApiOperation(value = "영화 목록 조회")
+	public ResponseEntity<MovieListResponse> getMovies() {
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(
+				MovieListResponse.from(
+					movieService.getMovies()
+				)
+			);
+	}
 
 }

server/src/main/java/com/ticketing/server/movie/application/MovieTimeController.java

@@ -0,0 +1,39 @@
+package com.ticketing.server.movie.application;
+
+import com.ticketing.server.movie.application.response.MovieTimeListResponse;
+import com.ticketing.server.movie.service.interfaces.MovieTimeService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import java.time.LocalDate;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/api/movieTimes")
+@Api(value = "MovieTime API", tags = {"Movie Time"})
+@RequiredArgsConstructor
+@Slf4j
+public class MovieTimeController {
+
+    private final MovieTimeService movieTimeService;
+
+    @GetMapping
+    @ApiOperation(value = "영화 시간표 조회")
+    @Validated
+    public ResponseEntity<MovieTimeListResponse> getMovieTimes(
+        @ApiParam(value = "영화 제목", required = true) @RequestParam String title,
+        @ApiParam(value = "상영 날짜", required = true) @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate runningDate) {
+        return ResponseEntity.status(HttpStatus.OK).body(MovieTimeListResponse.from(movieTimeService.getMovieTimes(title, runningDate)));
+    }
+
+
+}

server/src/main/java/com/ticketing/server/movie/application/MovieTimesController.java

@@ -1,8 +0,0 @@
-package com.ticketing.server.movie.application;
-
-import org.springframework.web.bind.annotation.RestController;
-
-@RestController
-public class MovieTimesController {
-
-}

server/src/main/java/com/ticketing/server/movie/application/TicketController.java

@@ -1,8 +1,30 @@
 package com.ticketing.server.movie.application;
 
+import com.ticketing.server.movie.application.response.TicketDetailsResponse;
+import com.ticketing.server.movie.service.dto.TicketDetailsDTO;
+import com.ticketing.server.movie.service.interfaces.TicketService;
+import javax.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
 @RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/tickets")
+@Validated
 public class TicketController {
 
+	private final TicketService ticketService;
+
+	@GetMapping("payments/{paymentId}")
+	public ResponseEntity<TicketDetailsResponse> findTicketsByPaymentId(@PathVariable("paymentId") @NotNull Long paymentId) {
+		TicketDetailsDTO tickets = ticketService.findTicketsByPaymentId(paymentId);
+		return ResponseEntity.status(HttpStatus.OK).body(tickets.toResponse());
+	}
+
 }

server/src/main/java/com/ticketing/server/movie/application/request/MovieRegisterRequest.java

@@ -0,0 +1,25 @@
+package com.ticketing.server.movie.application.request;
+
+import com.ticketing.server.movie.service.dto.MovieRegisterDTO;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@NoArgsConstructor
+@AllArgsConstructor
+public class MovieRegisterRequest {
+
+	@NotEmpty(message = "{validation.not.empty.title}")
+	private String title;
+
+	@NotNull(message = "{validation.not.null.runningTime}")
+	private Long runningTime;
+
+	public MovieRegisterDTO toMovieRegisterDTO() {
+		return new MovieRegisterDTO(this.title, this.runningTime);
+	}
+
+}

server/src/main/java/com/ticketing/server/movie/application/response/MovieListResponse.java

@@ -1,7 +1,6 @@
 package com.ticketing.server.movie.application.response;
 
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.ticketing.server.movie.service.dto.MovieDto;
+import com.ticketing.server.movie.service.dto.MovieDTO;
 import io.swagger.annotations.ApiModelProperty;
 import java.util.List;
 import lombok.AccessLevel;
@@ -13,10 +12,9 @@ import lombok.Getter;
 public class MovieListResponse {
 
     @ApiModelProperty(value = "영화 제목")
-    @JsonProperty
-    private List<MovieDto> movieDtos;
+    private List<MovieDTO> movieDtos;
 
-    public static MovieListResponse from(List<MovieDto> movieDtos) {
+    public static MovieListResponse from(List<MovieDTO> movieDtos) {
         return new MovieListResponse(movieDtos);
     }
 

server/src/main/java/com/ticketing/server/movie/application/response/MovieTimeListResponse.java

@@ -0,0 +1,21 @@
+package com.ticketing.server.movie.application.response;
+
+import com.ticketing.server.movie.service.dto.MovieTimeDTO;
+import io.swagger.annotations.ApiModelProperty;
+import java.util.List;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class MovieTimeListResponse {
+
+    @ApiModelProperty(value = "영화 시간표 정보")
+    private List<MovieTimeDTO> movieTimeDTOS;
+
+    public static MovieTimeListResponse from(List<MovieTimeDTO> movieTimeDtos) {
+        return new MovieTimeListResponse(movieTimeDtos);
+    }
+
+}

server/src/main/java/com/ticketing/server/movie/application/response/MovieTitleResponse.java

@@ -0,0 +1,20 @@
+package com.ticketing.server.movie.application.response;
+
+import com.ticketing.server.movie.service.dto.MovieDTO;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class MovieTitleResponse {
+
+	@ApiModelProperty(value = "영화 제목")
+	private String title;
+
+	public static MovieTitleResponse from(MovieDTO movieDto) {
+		return new MovieTitleResponse(movieDto.getTitle());
+	}
+
+}

server/src/main/java/com/ticketing/server/movie/application/response/TicketDetailsResponse.java

@@ -0,0 +1,16 @@
+package com.ticketing.server.movie.application.response;
+
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
+import java.util.List;
+import lombok.Getter;
+
+@Getter
+public class TicketDetailsResponse {
+
+	private final List<TicketDetailDTO> ticketDetails;
+
+	public TicketDetailsResponse(List<TicketDetailDTO> ticketDetails) {
+		this.ticketDetails = ticketDetails;
+	}
+
+}

server/src/main/java/com/ticketing/server/movie/domain/Movie.java

@@ -1,29 +1,31 @@
 package com.ticketing.server.movie.domain;
 
 import com.ticketing.server.global.dto.repository.AbstractEntity;
-import com.ticketing.server.movie.service.dto.MovieDto;
 import javax.persistence.Column;
 import javax.persistence.Entity;
 import javax.validation.constraints.NotNull;
+import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 
 @Entity
 @Getter
-@NoArgsConstructor
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
 @AllArgsConstructor
 public class Movie extends AbstractEntity {
 
-    @NotNull
-    @Column(unique = true)
-    private String title;
+	@NotNull
+	@Column(unique = true)
+	private String title;
 
-    @NotNull
-    private Integer runningTime;
+	@NotNull
+	private Long runningTime;
 
-    public MovieDto toDto() {
-        return new MovieDto(this.title);
-    }
+	Movie(Long id, String title, Long runningTime) {
+		this.id = id;
+		this.title = title;
+		this.runningTime = runningTime;
+	}
 
 }

server/src/main/java/com/ticketing/server/movie/domain/MovieTime.java

@@ -0,0 +1,75 @@
+package com.ticketing.server.movie.domain;
+
+import com.ticketing.server.global.dto.repository.AbstractEntity;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import javax.persistence.CascadeType;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.JoinColumn;
+import javax.persistence.ManyToOne;
+import javax.persistence.OneToMany;
+import javax.validation.constraints.NotNull;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class MovieTime extends AbstractEntity {
+
+	@NotNull
+	@ManyToOne(fetch = FetchType.LAZY)
+	@JoinColumn(name = "movie_id", referencedColumnName = "id", updatable = false)
+	private Movie movie;
+
+	@NotNull
+	@ManyToOne(fetch = FetchType.LAZY)
+	@JoinColumn(name = "theater_id", referencedColumnName = "id", updatable = false)
+	private Theater theater;
+
+	@NotNull
+	private Integer round;
+
+	@NotNull
+	private LocalDateTime startAt;
+
+	@NotNull
+	private LocalDateTime endAt;
+
+	@OneToMany(mappedBy = "movieTime", cascade = CascadeType.ALL)
+	private List<Ticket> tickets = new ArrayList<>();
+
+	public MovieTime(Movie movie, Theater theater, int round, LocalDateTime startAt) {
+		this.movie = movie;
+		this.theater = theater;
+		this.round = round;
+		this.startAt = startAt;
+		this.endAt = generateEndAt(startAt);
+	}
+
+	MovieTime(Long id, Movie movie, Theater theater, int round, LocalDateTime startAt) {
+		this.id = id;
+		this.movie = movie;
+		this.theater = theater;
+		this.round = round;
+		this.startAt = startAt;
+		this.endAt = generateEndAt(startAt);
+	}
+
+	private LocalDateTime generateEndAt(LocalDateTime startAt) {
+		Long runningTime = movie.getRunningTime();
+		return startAt.plusMinutes(runningTime);
+	}
+
+	public String getMovieTitle() {
+		return this.movie.getTitle();
+	}
+
+	public List<Seat> getSeats() {
+		return this.theater.getSeats();
+	}
+
+}

server/src/main/java/com/ticketing/server/movie/domain/MovieTimes.java

@@ -1,38 +0,0 @@
-package com.ticketing.server.movie.domain;
-
-import com.ticketing.server.global.dto.repository.AbstractEntity;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import javax.persistence.Entity;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.validation.constraints.NotNull;
-import lombok.Getter;
-
-@Entity
-@Getter
-public class MovieTimes extends AbstractEntity {
-
-	@NotNull
-	@ManyToOne
-	@JoinColumn(name = "movie_id", referencedColumnName = "id", updatable = false)
-	private Movie movie;
-
-	@NotNull
-	@ManyToOne
-	@JoinColumn(name = "theater_id", referencedColumnName = "id", updatable = false)
-	private Theater theater;
-
-	@NotNull
-	private LocalDate runningDate;
-
-	@NotNull
-	private Integer round;
-
-	@NotNull
-	private LocalDateTime startAt;
-
-	@NotNull
-	private LocalDateTime endAt;
-
-}

server/src/main/java/com/ticketing/server/movie/domain/Seat.java

@@ -2,17 +2,21 @@ package com.ticketing.server.movie.domain;
 
 import com.ticketing.server.global.dto.repository.AbstractEntity;
 import javax.persistence.Entity;
+import javax.persistence.FetchType;
 import javax.persistence.JoinColumn;
 import javax.persistence.ManyToOne;
 import javax.validation.constraints.NotNull;
+import lombok.AccessLevel;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
 
 @Entity
 @Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class Seat extends AbstractEntity {
 
 	@NotNull
-	@ManyToOne
+	@ManyToOne(fetch = FetchType.LAZY)
 	@JoinColumn(name = "theater_id", referencedColumnName = "id", updatable = false)
 	private Theater theater;
 
@@ -22,4 +26,26 @@ public class Seat extends AbstractEntity {
 	@NotNull
 	private Integer seatRow;
 
+	public Seat(Integer seatColumn, Integer seatRow, Theater theater) {
+		this.seatColumn = seatColumn;
+		this.seatRow = seatRow;
+		setTheater(theater);
+	}
+
+	Seat(Long id, int column, int row, Theater theater) {
+		this.id = id;
+		this.seatColumn = column;
+		this.seatRow = row;
+		setTheater(theater);
+	}
+
+	private void setTheater(Theater theater) {
+		this.theater = theater;
+		theater.addSeat(this);
+	}
+
+	public Integer getTheaterNumber() {
+		return this.theater.getTheaterNumber();
+	}
+
 }

server/src/main/java/com/ticketing/server/movie/domain/Theater.java

@@ -1,21 +1,38 @@
 package com.ticketing.server.movie.domain;
 
 import com.ticketing.server.global.dto.repository.AbstractEntity;
+import java.util.ArrayList;
+import java.util.List;
+import javax.persistence.CascadeType;
 import javax.persistence.Entity;
+import javax.persistence.OneToMany;
 import javax.validation.constraints.NotNull;
-import lombok.AllArgsConstructor;
+import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 
 @Entity
 @Getter
-@NoArgsConstructor
-@AllArgsConstructor
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class Theater extends AbstractEntity {
 
 	@NotNull
 	private Integer theaterNumber;
 
-	private Integer seatCount;
+	@OneToMany(mappedBy = "theater", cascade = CascadeType.ALL)
+	private List<Seat> seats = new ArrayList<>();
+
+	Theater(Long id, Integer theaterNumber) {
+		this.id = id;
+		this.theaterNumber = theaterNumber;
+	}
+
+	public Theater(Integer theaterNumber) {
+		this.theaterNumber = theaterNumber;
+	}
+
+	public void addSeat(Seat seat) {
+		seats.add(seat);
+	}
 
 }

server/src/main/java/com/ticketing/server/movie/domain/Ticket.java

@@ -1,35 +1,89 @@
 package com.ticketing.server.movie.domain;
 
 import com.ticketing.server.global.dto.repository.AbstractEntity;
-import com.ticketing.server.payment.domain.Payment;
+import com.ticketing.server.global.exception.ErrorCode;
+import java.time.LocalDateTime;
 import javax.persistence.Entity;
+import javax.persistence.EnumType;
+import javax.persistence.Enumerated;
+import javax.persistence.FetchType;
 import javax.persistence.JoinColumn;
 import javax.persistence.ManyToOne;
 import javax.validation.constraints.NotNull;
+import lombok.AccessLevel;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
 
 @Entity
 @Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class Ticket extends AbstractEntity {
 
 	@NotNull
-	@ManyToOne
+	@ManyToOne(fetch = FetchType.LAZY)
 	@JoinColumn(name = "seat_id", referencedColumnName = "id", updatable = false)
 	private Seat seat;
 
 	@NotNull
-	@ManyToOne
+	@ManyToOne(fetch = FetchType.LAZY)
 	@JoinColumn(name = "movie_times_id", referencedColumnName = "id", updatable = false)
-	private MovieTimes movieTimes;
+	private MovieTime movieTime;
 
-	@ManyToOne
-	@JoinColumn(name = "payment_id", referencedColumnName = "id", updatable = false)
-	private Payment payment;
+	private Long paymentId;
 
 	@NotNull
+	@Enumerated(EnumType.STRING)
 	private TicketStatus status;
 
 	@NotNull
 	private Integer ticketPrice;
 
+	public Ticket(Seat seat, MovieTime movieTime, Integer ticketPrice) {
+		this.seat = seat;
+		this.movieTime = movieTime;
+		this.ticketPrice = ticketPrice;
+		this.status = TicketStatus.SALE;
+	}
+
+	Ticket(Long id, Seat seat, MovieTime movieTime, Integer ticketPrice) {
+		this.id = id;
+		this.seat = seat;
+		this.movieTime = movieTime;
+		this.ticketPrice = ticketPrice;
+		this.status = TicketStatus.SALE;
+	}
+
+	public Integer getColumn() {
+		return this.seat.getSeatColumn();
+	}
+
+	public Integer getRow() {
+		return this.seat.getSeatRow();
+	}
+
+	public LocalDateTime getStartAt() {
+		return this.movieTime.getStartAt();
+	}
+
+	public LocalDateTime getEndAt() {
+		return this.movieTime.getEndAt();
+	}
+
+	public Integer getTheaterNumber() {
+		return this.seat.getTheaterNumber();
+	}
+
+	public String getMovieTitle() {
+		return this.movieTime.getMovieTitle();
+	}
+
+	public void registerPayment(Long id) {
+		if (this.paymentId != null) {
+			throw ErrorCode.throwDuplicatePayment();
+		}
+
+		this.paymentId = id;
+	}
+
+
 }

server/src/main/java/com/ticketing/server/movie/domain/TicketStatus.java

@@ -6,10 +6,11 @@ import lombok.Getter;
 @Getter
 @AllArgsConstructor
 public enum TicketStatus {
-    SALE("판매가능"),
-    SCHEDULED("환불"),
-    SOLD("판매완료");
 
-    private String name;
+	SALE("판매가능"),
+	SCHEDULED("환불"),
+	SOLD("판매완료");
+
+	private String name;
 
 }

server/src/main/java/com/ticketing/server/movie/domain/repository/MovieTimeRepository.java

@@ -0,0 +1,21 @@
+package com.ticketing.server.movie.domain.repository;
+
+import com.ticketing.server.movie.domain.Movie;
+import com.ticketing.server.movie.domain.MovieTime;
+import java.time.LocalDateTime;
+import java.util.List;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface MovieTimeRepository extends JpaRepository<MovieTime, Long> {
+
+    @Query(value = "SELECT mt "
+        + "FROM MovieTime mt "
+        + "JOIN FETCH mt.movie "
+        + "WHERE mt.movie = :movie "
+        + "AND mt.startAt BETWEEN :startOfDay AND :endOfDay ")
+    List<MovieTime> findValidMovieTimes(Movie movie, LocalDateTime startOfDay, LocalDateTime endOfDay);
+
+}

server/src/main/java/com/ticketing/server/movie/domain/repository/MovieTimesRepository.java

@@ -1,10 +0,0 @@
-package com.ticketing.server.movie.domain.repository;
-
-import com.ticketing.server.movie.domain.MovieTimes;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-
-@Repository
-public interface MovieTimesRepository extends JpaRepository<MovieTimes, Long> {
-
-}

server/src/main/java/com/ticketing/server/movie/domain/repository/TicketRepository.java

@@ -1,10 +1,24 @@
 package com.ticketing.server.movie.domain.repository;
 
 import com.ticketing.server.movie.domain.Ticket;
+import java.util.List;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
 
 @Repository
 public interface TicketRepository extends JpaRepository<Ticket, Long> {
 
+	@Query(
+		value =
+			"SELECT t "
+			+ "FROM Ticket t "
+			+ "JOIN FETCH t.movieTime mt "
+			+ "JOIN FETCH t.seat s "
+			+ "JOIN FETCH s.theater th "
+			+ "WHERE t.paymentId = :paymentId "
+	)
+	List<Ticket> findTicketFetchJoinByPaymentId(@Param("paymentId") Long paymentId);
+
 }

server/src/main/java/com/ticketing/server/movie/service/MovieServiceImpl.java

@@ -1,10 +1,13 @@
 package com.ticketing.server.movie.service;
 
+import com.ticketing.server.global.exception.ErrorCode;
 import com.ticketing.server.movie.domain.Movie;
 import com.ticketing.server.movie.domain.repository.MovieRepository;
-import com.ticketing.server.movie.service.dto.MovieDto;
+import com.ticketing.server.movie.service.dto.MovieDTO;
+import com.ticketing.server.movie.service.dto.MovieRegisterDTO;
 import com.ticketing.server.movie.service.interfaces.MovieService;
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -15,15 +18,27 @@ import org.springframework.stereotype.Service;
 @Slf4j
 public class MovieServiceImpl implements MovieService {
 
-    private final MovieRepository movieRepository;
+	private final MovieRepository movieRepository;
 
-    public List<MovieDto> getMovies() {
-        List<Movie> movies = movieRepository.findValidMovies();
+	@Override
+	public MovieDTO registerMovie(MovieRegisterDTO movieRegisterDto) {
+		Optional<Movie> movie = movieRepository.findByTitle(movieRegisterDto.getTitle());
 
-        return movies.stream()
-            .map(movie -> movie.toDto())
-            .collect(Collectors.toList());
+		if(movie.isEmpty()) {
+			return MovieDTO.from(movieRepository.save(movieRegisterDto.toMovie()));
+		}
 
-    }
+		throw ErrorCode.throwDuplicateMovie();
+	}
+
+	@Override
+	public List<MovieDTO> getMovies() {
+		List<Movie> movies = movieRepository.findValidMovies();
+
+		return movies.stream()
+			.map(MovieDTO::from)
+			.collect(Collectors.toList());
+
+	}
 
 }

server/src/main/java/com/ticketing/server/movie/service/MovieTimeServiceImpl.java

@@ -0,0 +1,43 @@
+package com.ticketing.server.movie.service;
+
+import com.ticketing.server.global.exception.ErrorCode;
+import com.ticketing.server.movie.domain.Movie;
+import com.ticketing.server.movie.domain.MovieTime;
+import com.ticketing.server.movie.domain.repository.MovieRepository;
+import com.ticketing.server.movie.domain.repository.MovieTimeRepository;
+import com.ticketing.server.movie.service.dto.MovieTimeDTO;
+import com.ticketing.server.movie.service.interfaces.MovieTimeService;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.stream.Collectors;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class MovieTimeServiceImpl implements MovieTimeService {
+
+	private final MovieRepository movieRepository;
+
+	private final MovieTimeRepository movieTimeRepository;
+
+	@Override
+	public List<MovieTimeDTO> getMovieTimes(String title, LocalDate runningDate) {
+		Movie movie = movieRepository.findByTitle(title)
+			.orElseThrow(ErrorCode::throwMovieNotFound);
+
+		LocalDateTime startOfDay = runningDate.atStartOfDay().plusHours(6);
+		LocalDateTime endOfDay = startOfDay.plusDays(1);
+
+		List<MovieTime> movieTimes = movieTimeRepository.findValidMovieTimes(movie, startOfDay, endOfDay);
+
+		return movieTimes.stream()
+			.map(MovieTimeDTO::from)
+			.collect(Collectors.toList());
+
+	}
+
+}

server/src/main/java/com/ticketing/server/movie/service/MovieTimesServiceImpl.java

@@ -1,9 +0,0 @@
-package com.ticketing.server.movie.service;
-
-import com.ticketing.server.movie.service.interfaces.MovieTimesService;
-import org.springframework.stereotype.Service;
-
-@Service
-public class MovieTimesServiceImpl implements MovieTimesService {
-
-}

server/src/main/java/com/ticketing/server/movie/service/TMBDServiceImpl.java

@@ -1,9 +0,0 @@
-package com.ticketing.server.movie.service;
-
-import com.ticketing.server.movie.service.interfaces.TMDBService;
-import org.springframework.stereotype.Service;
-
-@Service
-public class TMBDServiceImpl implements TMDBService {
-
-}

server/src/main/java/com/ticketing/server/movie/service/TicketServiceImpl.java

@@ -1,9 +1,40 @@
 package com.ticketing.server.movie.service;
 
+import com.ticketing.server.global.exception.ErrorCode;
+import com.ticketing.server.movie.domain.repository.TicketRepository;
+import com.ticketing.server.movie.service.dto.TicketDetailsDTO;
 import com.ticketing.server.movie.service.interfaces.TicketService;
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.validation.annotation.Validated;
 
 @Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+@Validated
+@Slf4j
 public class TicketServiceImpl implements TicketService {
 
+	private final TicketRepository ticketRepository;
+
+	@Override
+	public TicketDetailsDTO findTicketsByPaymentId(@NotNull Long paymentId) {
+		List<TicketDetailDTO> ticketDetails = ticketRepository.findTicketFetchJoinByPaymentId(paymentId)
+			.stream()
+			.map(TicketDetailDTO::new)
+			.collect(Collectors.toList());
+
+		if (ticketDetails.isEmpty()) {
+			throw ErrorCode.throwPaymentIdNotFound();
+		}
+
+		return new TicketDetailsDTO(ticketDetails);
+	}
+
 }

server/src/main/java/com/ticketing/server/movie/service/dto/MovieDTO.java

@@ -0,0 +1,18 @@
+package com.ticketing.server.movie.service.dto;
+
+import com.ticketing.server.movie.domain.Movie;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class MovieDTO {
+
+    private String title;
+
+    public static MovieDTO from(Movie movie) {
+        return new MovieDTO(movie.getTitle());
+    }
+
+}

server/src/main/java/com/ticketing/server/movie/service/dto/MovieDto.java

@@ -1,12 +0,0 @@
-package com.ticketing.server.movie.service.dto;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.AllArgsConstructor;
-
-@AllArgsConstructor
-public class MovieDto {
-
-    @JsonProperty
-    private String title;
-
-}

server/src/main/java/com/ticketing/server/movie/service/dto/MovieRegisterDTO.java

@@ -0,0 +1,24 @@
+package com.ticketing.server.movie.service.dto;
+
+import com.ticketing.server.movie.domain.Movie;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@NoArgsConstructor
+@AllArgsConstructor
+public class MovieRegisterDTO {
+
+	@NotEmpty(message = "{validation.not.empty.title}")
+	private String title;
+
+	@NotNull(message = "{validation.not.null.runningTime}")
+	private Long runningTime;
+
+	public Movie toMovie() {
+		return new Movie(this.title, this.runningTime);
+	}
+}

server/src/main/java/com/ticketing/server/movie/service/dto/MovieTimeDTO.java

@@ -0,0 +1,28 @@
+package com.ticketing.server.movie.service.dto;
+
+import com.ticketing.server.movie.domain.MovieTime;
+import java.time.LocalDateTime;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class MovieTimeDTO {
+
+    private Long movieTimeId;
+
+    private Integer theaterNumber;
+
+    private Integer round;
+
+    private LocalDateTime startAt;
+
+    private LocalDateTime endAt;
+
+    public static MovieTimeDTO from(MovieTime movieTime) {
+        return new MovieTimeDTO(movieTime.getId(), movieTime.getTheater().getTheaterNumber(),
+            movieTime.getRound(), movieTime.getStartAt(), movieTime.getEndAt());
+    }
+
+}

server/src/main/java/com/ticketing/server/movie/service/dto/TicketDetailsDTO.java

@@ -0,0 +1,18 @@
+package com.ticketing.server.movie.service.dto;
+
+import com.ticketing.server.movie.application.response.TicketDetailsResponse;
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class TicketDetailsDTO {
+
+	private final List<TicketDetailDTO> ticketDetails;
+
+	public TicketDetailsResponse toResponse() {
+		return new TicketDetailsResponse(ticketDetails);
+	}
+}

server/src/main/java/com/ticketing/server/movie/service/interfaces/MovieService.java

@@ -1,10 +1,13 @@
 package com.ticketing.server.movie.service.interfaces;
 
-import com.ticketing.server.movie.service.dto.MovieDto;
+import com.ticketing.server.movie.service.dto.MovieDTO;
+import com.ticketing.server.movie.service.dto.MovieRegisterDTO;
 import java.util.List;
 
 public interface MovieService {
 
-    List<MovieDto> getMovies();
+	MovieDTO registerMovie(MovieRegisterDTO movieRegisterDto);
+
+    List<MovieDTO> getMovies();
 
 }

server/src/main/java/com/ticketing/server/movie/service/interfaces/MovieTimeService.java

@@ -0,0 +1,11 @@
+package com.ticketing.server.movie.service.interfaces;
+
+import com.ticketing.server.movie.service.dto.MovieTimeDTO;
+import java.time.LocalDate;
+import java.util.List;
+
+public interface MovieTimeService {
+
+    List<MovieTimeDTO> getMovieTimes(String title, LocalDate runningDate);
+
+}

server/src/main/java/com/ticketing/server/movie/service/interfaces/MovieTimesService.java

@@ -1,5 +0,0 @@
-package com.ticketing.server.movie.service.interfaces;
-
-public interface MovieTimesService {
-
-}

server/src/main/java/com/ticketing/server/movie/service/interfaces/TMDBService.java

@@ -1,5 +0,0 @@
-package com.ticketing.server.movie.service.interfaces;
-
-public interface TMDBService {
-
-}

server/src/main/java/com/ticketing/server/movie/service/interfaces/TicketService.java

@@ -1,5 +1,10 @@
 package com.ticketing.server.movie.service.interfaces;
 
+import com.ticketing.server.movie.service.dto.TicketDetailsDTO;
+import javax.validation.constraints.NotNull;
+
 public interface TicketService {
 
+	TicketDetailsDTO findTicketsByPaymentId(@NotNull Long paymentId);
+
 }

server/src/main/java/com/ticketing/server/movie/setup/MovieSetupController.java

@@ -0,0 +1,20 @@
+package com.ticketing.server.movie.setup;
+
+import javax.annotation.PostConstruct;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Profile;
+import org.springframework.web.bind.annotation.RestController;
+
+@Profile(value = {"local"})
+@RestController
+@RequiredArgsConstructor
+public class MovieSetupController {
+
+	private final MovieSetupService movieSetupService;
+
+	@PostConstruct
+	public void setup() {
+		movieSetupService.init();
+	}
+
+}

server/src/main/java/com/ticketing/server/movie/setup/MovieSetupService.java

@@ -0,0 +1,131 @@
+package com.ticketing.server.movie.setup;
+
+import com.ticketing.server.movie.domain.Movie;
+import com.ticketing.server.movie.domain.MovieTime;
+import com.ticketing.server.movie.domain.Seat;
+import com.ticketing.server.movie.domain.Theater;
+import com.ticketing.server.movie.domain.Ticket;
+import com.ticketing.server.movie.domain.repository.MovieRepository;
+import com.ticketing.server.movie.domain.repository.MovieTimeRepository;
+import com.ticketing.server.movie.domain.repository.TheaterRepository;
+import com.ticketing.server.movie.domain.repository.TicketRepository;
+import com.ticketing.server.payment.domain.Payment;
+import com.ticketing.server.payment.domain.PaymentStatus;
+import com.ticketing.server.payment.domain.PaymentType;
+import com.ticketing.server.payment.domain.repository.PaymentRepository;
+import com.ticketing.server.payment.service.dto.CreatePaymentDTO;
+import com.ticketing.server.user.domain.User;
+import com.ticketing.server.user.domain.UserGrade;
+import com.ticketing.server.user.domain.repository.UserRepository;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@RequiredArgsConstructor
+public class
+MovieSetupService {
+
+	private final UserRepository userRepository;
+	private final MovieRepository movieRepository;
+	private final MovieTimeRepository movieTimeRepository;
+	private final TheaterRepository theaterRepository;
+	private final TicketRepository ticketRepository;
+	private final PaymentRepository paymentRepository;
+
+	private final PasswordEncoder passwordEncoder;
+
+	@Transactional
+	public void init() {
+		initMovie();
+		initTheater();
+		initMovieTime();
+		initTicket();
+		initPayment();
+	}
+
+	private void initMovie() {
+		List<Movie> movies = Arrays.asList(
+			new Movie("탑건: 매버릭", 130L),
+			new Movie("헤어질 결심", 138L),
+			new Movie("마녀2", 137L),
+			new Movie("범죄도시2", 106L),
+			new Movie("버즈 라이트이어", 105L)
+		);
+
+		movieRepository.saveAll(movies);
+	}
+
+	private void initTheater() {
+		List<Theater> theaters = Arrays.asList(
+			new Theater(1),
+			new Theater(2)
+		);
+
+		for (Theater theater : theaters) {
+			for (int col = 1; col <= 2; col++) {
+				for (int row = 1; row <= 10; row++) {
+					new Seat(col, row, theater);
+				}
+			}
+		}
+
+		theaterRepository.saveAll(theaters);
+	}
+
+	private void initMovieTime() {
+		List<Movie> movies = movieRepository.findAll();
+		List<Theater> theaters = theaterRepository.findAll();
+
+		LocalDateTime now = LocalDateTime.now();
+
+		List<MovieTime> movieTimes = new ArrayList<>();
+		for (Theater theater : theaters) {
+			movieTimes.add(new MovieTime(movies.get(0), theater, 1, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 8, 0)));
+			movieTimes.add(new MovieTime(movies.get(0), theater, 3, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 12, 0)));
+			movieTimes.add(new MovieTime(movies.get(1), theater, 2, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 10, 0)));
+			movieTimes.add(new MovieTime(movies.get(2), theater, 4, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 14, 0)));
+			movieTimes.add(new MovieTime(movies.get(0), theater, 5, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 16, 0)));
+			movieTimes.add(new MovieTime(movies.get(3), theater, 6, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 18, 0)));
+			movieTimes.add(new MovieTime(movies.get(0), theater, 7, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 21, 0)));
+			movieTimes.add(new MovieTime(movies.get(4), theater, 8, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 23, 0)));
+		}
+
+		movieTimeRepository.saveAll(movieTimes);
+	}
+
+	private void initTicket() {
+		List<MovieTime> movieTimes = movieTimeRepository.findAll();
+
+		List<Ticket> tickets = new ArrayList<>();
+		Integer ticketPrice = 15_000;
+		for (MovieTime movieTime : movieTimes) {
+			for (Seat seat : movieTime.getSeats()) {
+				tickets.add(new Ticket(seat, movieTime, ticketPrice));
+			}
+		}
+
+		ticketRepository.saveAll(tickets);
+	}
+
+	private void initPayment() {
+		User user = userRepository.save(new User(123L, "김동효", "kdhyo98@gmail.com", passwordEncoder.encode("123123"), UserGrade.USER, "010-1234-5678"));
+
+		List<Ticket> tickets = ticketRepository.findAll();
+		Ticket ticket = tickets.get(0);
+		String title = ticket.getMovieTime().getMovie().getTitle();
+		CreatePaymentDTO createPaymentDto = new CreatePaymentDTO(user.getAlternateId(), title, PaymentType.KAKAO_PAY, PaymentStatus.COMPLETED, "2022-0710-4142", 30_000);
+		Payment payment = createPaymentDto.toEntity();
+
+		paymentRepository.save(payment);
+
+		ticket.registerPayment(payment.getId());
+		tickets.get(1).registerPayment(payment.getId());
+	}
+
+}

server/src/main/java/com/ticketing/server/payment/api/MovieClient.java

@@ -0,0 +1,10 @@
+package com.ticketing.server.payment.api;
+
+import com.ticketing.server.movie.application.response.TicketDetailsResponse;
+import javax.validation.constraints.NotNull;
+
+public interface MovieClient {
+
+	TicketDetailsResponse getTicketsByPaymentId(@NotNull Long paymentId);
+
+}

server/src/main/java/com/ticketing/server/payment/api/UserClient.java

@@ -0,0 +1,8 @@
+package com.ticketing.server.payment.api;
+
+import com.ticketing.server.payment.api.dto.response.UserDetailResponse;
+
+public interface UserClient {
+
+	UserDetailResponse detail();
+}

server/src/main/java/com/ticketing/server/payment/api/dto/response/UserDetailResponse.java

@@ -0,0 +1,34 @@
+package com.ticketing.server.payment.api.dto.response;
+
+import com.ticketing.server.payment.domain.Payment;
+import com.ticketing.server.user.domain.UserGrade;
+import com.ticketing.server.user.service.dto.UserDetailDTO;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class UserDetailResponse {
+
+	private final Long userAlternateId;
+	private final String name;
+	private final String email;
+	private final UserGrade grade;
+	private final String phone;
+
+	public UserDetailResponse(UserDetailDTO userDetailDto) {
+		this(
+			userDetailDto.getAlternateId(),
+			userDetailDto.getName(),
+			userDetailDto.getEmail(),
+			userDetailDto.getGrade(),
+			userDetailDto.getPhone()
+		);
+	}
+
+	public boolean hasUserAlternateId(Payment payment) {
+		return userAlternateId.equals(payment.getUserAlternateId());
+	}
+
+}

server/src/main/java/com/ticketing/server/payment/api/impl/MovieClientImpl.java

@@ -0,0 +1,25 @@
+package com.ticketing.server.payment.api.impl;
+
+import com.ticketing.server.movie.application.response.TicketDetailsResponse;
+import com.ticketing.server.movie.service.dto.TicketDetailsDTO;
+import com.ticketing.server.movie.service.interfaces.TicketService;
+import com.ticketing.server.payment.api.MovieClient;
+import javax.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.validation.annotation.Validated;
+
+@Service
+@RequiredArgsConstructor
+@Validated
+public class MovieClientImpl implements MovieClient {
+
+	private final TicketService ticketService;
+
+	@Override
+	public TicketDetailsResponse getTicketsByPaymentId(@NotNull Long paymentId) {
+		TicketDetailsDTO ticketDetails = ticketService.findTicketsByPaymentId(paymentId);
+		return ticketDetails.toResponse();
+	}
+
+}

server/src/main/java/com/ticketing/server/payment/api/impl/UserClientImpl.java

@@ -0,0 +1,28 @@
+package com.ticketing.server.payment.api.impl;
+
+import com.ticketing.server.payment.api.UserClient;
+import com.ticketing.server.payment.api.dto.response.UserDetailResponse;
+import com.ticketing.server.user.service.dto.UserDetailDTO;
+import com.ticketing.server.user.service.interfaces.UserService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class UserClientImpl implements UserClient {
+
+	private final UserService userService;
+
+	@Override
+	public UserDetailResponse detail() {
+		Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+		UserDetails details = (UserDetails) authentication.getPrincipal();
+
+		UserDetailDTO userDetail = userService.findDetailByEmail(details.getUsername());
+		return new UserDetailResponse(userDetail);
+	}
+
+}

server/src/main/java/com/ticketing/server/payment/application/PaymentController.java

@@ -1,8 +1,47 @@
 package com.ticketing.server.payment.application;
 
+import com.ticketing.server.payment.application.response.PaymentDetailResponse;
+import com.ticketing.server.payment.application.response.SimplePaymentsResponse;
+import com.ticketing.server.payment.service.dto.PaymentDetailDTO;
+import com.ticketing.server.payment.service.dto.SimplePaymentsDTO;
+import com.ticketing.server.payment.service.interfaces.PaymentApisService;
+import com.ticketing.server.payment.service.interfaces.PaymentService;
+import com.ticketing.server.user.domain.UserGrade;
+import javax.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.annotation.Secured;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
 @RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/payments")
+@Validated
 public class PaymentController {
 
+	private final PaymentApisService paymentApisService;
+	private final PaymentService paymentService;
+
+	@GetMapping
+	@Secured(UserGrade.ROLES.USER)
+	public ResponseEntity<SimplePaymentsResponse> simplePayments(@NotNull Long userAlternateId) {
+		SimplePaymentsDTO simplePayments = paymentService.findSimplePayments(userAlternateId);
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(simplePayments.toResponse());
+	}
+
+	@GetMapping("/detail")
+	@Secured(UserGrade.ROLES.USER)
+	public ResponseEntity<PaymentDetailResponse> detail(@NotNull Long paymentId) {
+		PaymentDetailDTO paymentDetail = paymentApisService.findPaymentDetail(paymentId);
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(paymentDetail.toResponse());
+	}
+
 }

server/src/main/java/com/ticketing/server/payment/application/response/PaymentDetailResponse.java

@@ -0,0 +1,20 @@
+package com.ticketing.server.payment.application.response;
+
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
+import java.time.LocalDateTime;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class PaymentDetailResponse {
+
+	private Long paymentId;
+	private String movieTitle;
+	private String paymentNumber;
+	private Integer totalPrice;
+	private LocalDateTime createdAt;
+	private List<TicketDetailDTO> tickets;
+
+}

server/src/main/java/com/ticketing/server/payment/application/response/SimplePaymentsResponse.java

@@ -0,0 +1,15 @@
+package com.ticketing.server.payment.application.response;
+
+import com.ticketing.server.payment.service.dto.SimplePaymentDTO;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class SimplePaymentsResponse {
+
+	private final Long userAlternateId;
+	private final List<SimplePaymentDTO> payments;
+
+}

server/src/main/java/com/ticketing/server/payment/domain/Payment.java

@@ -1,38 +1,67 @@
 package com.ticketing.server.payment.domain;
 
 import com.ticketing.server.global.dto.repository.AbstractEntity;
-import com.ticketing.server.user.domain.User;
+import javax.persistence.Column;
 import javax.persistence.Entity;
 import javax.persistence.EnumType;
 import javax.persistence.Enumerated;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
+import javax.validation.constraints.NotEmpty;
 import javax.validation.constraints.NotNull;
+import lombok.AccessLevel;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
 
 @Entity
 @Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class Payment extends AbstractEntity {
 
 	@NotNull
-	@ManyToOne
-	@JoinColumn(name = "user_id", referencedColumnName = "id", updatable = false)
-	private User user;
+	@Column(name = "user_alternate_id", nullable = false)
+	private Long userAlternateId;
+
+	@NotEmpty
+	@Column(name = "movie_title", nullable = false)
+	private String movieTitle;
 
 	@NotNull
+	@Column(name = "type", nullable = false)
 	@Enumerated(value = EnumType.STRING)
 	private PaymentType type;
 
 	@NotNull
+	@Column(name = "status", nullable = false)
 	@Enumerated(value = EnumType.STRING)
 	private PaymentStatus status;
 
+	@Column(name = "failed_message")
 	private String failedMessage;
 
-	@NotNull
+	@NotEmpty
+	@Column(name = "payment_number", nullable = false)
 	private String paymentNumber;
 
 	@NotNull
+	@Column(name = "total_price", nullable = false)
 	private Integer totalPrice;
 
+	public Payment(Long userAlternateId, String movieTitle, PaymentType type, PaymentStatus status, String paymentNumber, Integer totalPrice) {
+		this.userAlternateId = userAlternateId;
+		this.movieTitle = movieTitle;
+		this.type = type;
+		this.status = status;
+		this.paymentNumber = paymentNumber;
+		this.totalPrice = totalPrice;
+	}
+
+	Payment(Long id, Long userAlternateId, String movieTitle, PaymentType type, PaymentStatus status, String paymentNumber, Integer totalPrice) {
+		this.id = id;
+		this.userAlternateId = userAlternateId;
+		this.movieTitle = movieTitle;
+		this.type = type;
+		this.status = status;
+		this.paymentNumber = paymentNumber;
+		this.totalPrice = totalPrice;
+	}
+
 }

server/src/main/java/com/ticketing/server/payment/domain/repository/PaymentRepository.java

@@ -1,10 +1,13 @@
 package com.ticketing.server.payment.domain.repository;
 
 import com.ticketing.server.payment.domain.Payment;
+import java.util.List;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
 @Repository
 public interface PaymentRepository extends JpaRepository<Payment, Long> {
 
+	List<Payment> findByUserAlternateId(Long userId);
+
 }

server/src/main/java/com/ticketing/server/payment/service/PaymentApisServiceImpl.java

@@ -0,0 +1,44 @@
+package com.ticketing.server.payment.service;
+
+import com.ticketing.server.global.exception.ErrorCode;
+import com.ticketing.server.movie.application.response.TicketDetailsResponse;
+import com.ticketing.server.payment.api.MovieClient;
+import com.ticketing.server.payment.api.UserClient;
+import com.ticketing.server.payment.api.dto.response.UserDetailResponse;
+import com.ticketing.server.payment.domain.Payment;
+import com.ticketing.server.payment.domain.repository.PaymentRepository;
+import com.ticketing.server.payment.service.dto.PaymentDetailDTO;
+import com.ticketing.server.payment.service.interfaces.PaymentApisService;
+import javax.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.validation.annotation.Validated;
+
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+@Validated
+@Slf4j
+public class PaymentApisServiceImpl implements PaymentApisService {
+
+	private final PaymentRepository paymentRepository;
+	private final MovieClient movieClient;
+	private final UserClient userClient;
+
+	@Override
+	public PaymentDetailDTO findPaymentDetail(@NotNull Long paymentId) {
+		Payment payment = paymentRepository.findById(paymentId)
+			.orElseThrow(ErrorCode::throwPaymentIdNotFound);
+
+		UserDetailResponse userDetail = userClient.detail();
+		if (!userDetail.hasUserAlternateId(payment)) {
+			throw ErrorCode.throwValidUserId();
+		}
+
+		TicketDetailsResponse tickets = movieClient.getTicketsByPaymentId(payment.getId());
+		return new PaymentDetailDTO(payment, tickets);
+	}
+
+}

server/src/main/java/com/ticketing/server/payment/service/PaymentServiceImpl.java

@@ -1,9 +1,37 @@
 package com.ticketing.server.payment.service;
 
+import com.ticketing.server.payment.domain.repository.PaymentRepository;
+import com.ticketing.server.payment.service.dto.SimplePaymentDTO;
+import com.ticketing.server.payment.service.dto.SimplePaymentsDTO;
 import com.ticketing.server.payment.service.interfaces.PaymentService;
+import java.util.stream.Collectors;
+import javax.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.validation.annotation.Validated;
 
 @Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+@Validated
+@Slf4j
 public class PaymentServiceImpl implements PaymentService {
 
+	private final PaymentRepository paymentRepository;
+
+	@Override
+	public SimplePaymentsDTO findSimplePayments(@NotNull Long userAlternateId) {
+		return paymentRepository.findByUserAlternateId(userAlternateId)
+			.stream()
+			.map(SimplePaymentDTO::new)
+			.collect(Collectors
+				.collectingAndThen(
+					Collectors.toList()
+					, payments -> new SimplePaymentsDTO(userAlternateId, payments)
+				)
+			);
+	}
+
 }

server/src/main/java/com/ticketing/server/payment/service/dto/CreatePaymentDTO.java

@@ -0,0 +1,32 @@
+package com.ticketing.server.payment.service.dto;
+
+import com.ticketing.server.payment.domain.Payment;
+import com.ticketing.server.payment.domain.PaymentStatus;
+import com.ticketing.server.payment.domain.PaymentType;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class CreatePaymentDTO {
+
+	private final Long userAlternateId;
+	private final String movieTitle;
+	private final PaymentType type;
+	private final PaymentStatus status;
+	private final String paymentNumber;
+	private final Integer totalPrice;
+
+	public Payment toEntity() {
+		return new Payment
+			(
+				this.getUserAlternateId(),
+				this.getMovieTitle(),
+				this.getType(),
+				this.getStatus(),
+				this.getPaymentNumber(),
+				this.getTotalPrice()
+			);
+	}
+
+}

server/src/main/java/com/ticketing/server/payment/service/dto/PaymentDetailDTO.java

@@ -0,0 +1,39 @@
+package com.ticketing.server.payment.service.dto;
+
+import com.ticketing.server.movie.application.response.TicketDetailsResponse;
+import com.ticketing.server.payment.application.response.PaymentDetailResponse;
+import com.ticketing.server.payment.domain.Payment;
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
+import java.time.LocalDateTime;
+import java.util.List;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class PaymentDetailDTO {
+
+	private final Long paymentId;
+	private final String movieTitle;
+	private final String paymentNumber;
+	private final Integer totalPrice;
+	private final LocalDateTime createdAt;
+	private final List<TicketDetailDTO> tickets;
+
+	public PaymentDetailDTO(Payment payment, TicketDetailsResponse ticketDetails) {
+		this(
+			payment.getId(),
+			payment.getMovieTitle(),
+			payment.getPaymentNumber(),
+			payment.getTotalPrice(),
+			payment.getCreatedAt(),
+			ticketDetails.getTicketDetails()
+		);
+	}
+
+	public PaymentDetailResponse toResponse() {
+		return new PaymentDetailResponse(paymentId, movieTitle, paymentNumber, totalPrice, createdAt, tickets);
+	}
+
+}

server/src/main/java/com/ticketing/server/payment/service/dto/SimplePaymentDTO.java

@@ -0,0 +1,25 @@
+package com.ticketing.server.payment.service.dto;
+
+import com.ticketing.server.payment.domain.Payment;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class SimplePaymentDTO {
+
+	private final Long paymentId;
+	private final String movieTitle;
+	private final String paymentNumber;
+	private final Integer totalPrice;
+
+	public SimplePaymentDTO(Payment payment) {
+		this(
+			payment.getId(),
+			payment.getMovieTitle(),
+			payment.getPaymentNumber(),
+			payment.getTotalPrice()
+		);
+	}
+}

server/src/main/java/com/ticketing/server/payment/service/dto/SimplePaymentsDTO.java

@@ -0,0 +1,19 @@
+package com.ticketing.server.payment.service.dto;
+
+import com.ticketing.server.payment.application.response.SimplePaymentsResponse;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class SimplePaymentsDTO {
+
+	private final Long userAlternateId;
+	private final List<SimplePaymentDTO> payments;
+
+	public SimplePaymentsResponse toResponse() {
+		return new SimplePaymentsResponse(userAlternateId, payments);
+	}
+
+}

server/src/main/java/com/ticketing/server/payment/service/dto/TicketDetailDTO.java

@@ -0,0 +1,31 @@
+package com.ticketing.server.payment.service.dto;
+
+import com.ticketing.server.movie.domain.Ticket;
+import java.time.LocalDateTime;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class TicketDetailDTO {
+
+	private final Integer price;
+	private final Integer theaterNumber;
+	private final Integer column;
+	private final Integer row;
+	private final LocalDateTime startAt;
+	private final LocalDateTime endAt;
+
+	public TicketDetailDTO(Ticket ticket) {
+		this(
+			ticket.getTicketPrice(),
+			ticket.getTheaterNumber(),
+			ticket.getColumn(),
+			ticket.getRow(),
+			ticket.getStartAt(),
+			ticket.getEndAt()
+		);
+	}
+
+}

server/src/main/java/com/ticketing/server/payment/service/interfaces/PaymentApisService.java

@@ -0,0 +1,9 @@
+package com.ticketing.server.payment.service.interfaces;
+
+import com.ticketing.server.payment.service.dto.PaymentDetailDTO;
+import javax.validation.constraints.NotNull;
+
+public interface PaymentApisService {
+
+	PaymentDetailDTO findPaymentDetail(@NotNull Long paymentId);
+}

server/src/main/java/com/ticketing/server/payment/service/interfaces/PaymentService.java

@@ -1,5 +1,10 @@
 package com.ticketing.server.payment.service.interfaces;
 
+import com.ticketing.server.payment.service.dto.SimplePaymentsDTO;
+import javax.validation.constraints.NotNull;
+
 public interface PaymentService {
 
+	SimplePaymentsDTO findSimplePayments(@NotNull Long userAlternateId);
+
 }

server/src/main/java/com/ticketing/server/user/api/PaymentClient.java

@@ -0,0 +1,10 @@
+package com.ticketing.server.user.api;
+
+import com.ticketing.server.payment.application.response.SimplePaymentsResponse;
+import javax.validation.constraints.NotNull;
+
+public interface PaymentClient {
+
+	SimplePaymentsResponse getPayments(@NotNull Long alternateId);
+
+}

server/src/main/java/com/ticketing/server/user/api/impl/PaymentClientImpl.java

@@ -0,0 +1,23 @@
+package com.ticketing.server.user.api.impl;
+
+import com.ticketing.server.payment.application.response.SimplePaymentsResponse;
+import com.ticketing.server.payment.service.dto.SimplePaymentsDTO;
+import com.ticketing.server.payment.service.interfaces.PaymentService;
+import com.ticketing.server.user.api.PaymentClient;
+import javax.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class PaymentClientImpl implements PaymentClient {
+
+	private final PaymentService paymentService;
+
+	@Override
+	public SimplePaymentsResponse getPayments(@NotNull Long alternateId) {
+		SimplePaymentsDTO payments = paymentService.findSimplePayments(alternateId);
+		return payments.toResponse();
+	}
+
+}

server/src/main/java/com/ticketing/server/user/application/AuthController.java

@@ -2,7 +2,9 @@ package com.ticketing.server.user.application;
 
 import com.ticketing.server.user.application.request.LoginRequest;
 import com.ticketing.server.user.application.response.LogoutResponse;
-import com.ticketing.server.user.application.response.TokenDto;
+import com.ticketing.server.user.service.dto.TokenDTO;
+import com.ticketing.server.user.application.response.TokenResponse;
+import com.ticketing.server.user.service.dto.DeleteRefreshTokenDTO;
 import com.ticketing.server.user.service.interfaces.AuthenticationService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -26,29 +28,29 @@ public class AuthController {
 	private final AuthenticationService authenticationService;
 
 	@PostMapping("/token")
-	public ResponseEntity<TokenDto> login(@RequestBody LoginRequest loginRequest) {
-		TokenDto tokenDto = authenticationService.generateTokenDto(loginRequest.toAuthentication());
+	public ResponseEntity<TokenResponse> login(@RequestBody LoginRequest loginRequest) {
+		TokenDTO tokenDto = authenticationService.generateTokenDto(loginRequest.toAuthentication());
 
 		return ResponseEntity.status(HttpStatus.OK)
 			.headers(getHttpHeaders())
-			.body(tokenDto);
+			.body(tokenDto.toResponse());
 	}
 
 	@PostMapping("/refresh")
-	public ResponseEntity<TokenDto> refreshToken(@RequestParam("refreshToken") String refreshToken) {
-		TokenDto tokenDto = authenticationService.reissueTokenDto(refreshToken);
+	public ResponseEntity<TokenResponse> refreshToken(@RequestParam("refreshToken") String refreshToken) {
+		TokenDTO tokenDto = authenticationService.reissueTokenDto(refreshToken);
 
 		return ResponseEntity.status(HttpStatus.OK)
 			.headers(getHttpHeaders())
-			.body(tokenDto);
+			.body(tokenDto.toResponse());
 	}
 
 	@PostMapping("/logout")
 	public ResponseEntity<LogoutResponse> logout(@AuthenticationPrincipal UserDetails userRequest) {
-		LogoutResponse logoutResponse = authenticationService.deleteRefreshToken(userRequest.getUsername());
+		DeleteRefreshTokenDTO refreshToken = authenticationService.deleteRefreshToken(userRequest.getUsername());
 
 		return ResponseEntity.status(HttpStatus.OK)
-			.body(logoutResponse);
+			.body(refreshToken.toResponse());
 	}
 
 	private HttpHeaders getHttpHeaders() {

server/src/main/java/com/ticketing/server/user/application/UserChangeGradeResponse.java

@@ -0,0 +1,17 @@
+package com.ticketing.server.user.application;
+
+import com.ticketing.server.user.domain.UserGrade;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class UserChangeGradeResponse {
+
+	private String email;
+
+	private UserGrade beforeGrade;
+
+	private UserGrade afterGrade;
+
+}

server/src/main/java/com/ticketing/server/user/application/UserController.java

@@ -1,15 +1,26 @@
 package com.ticketing.server.user.application;
 
+import static com.ticketing.server.user.domain.UserGrade.ROLES.ADMIN;
+import static com.ticketing.server.user.domain.UserGrade.ROLES.USER;
+
 import com.ticketing.server.user.application.request.SignUpRequest;
+import com.ticketing.server.user.application.request.UserChangeGradeRequest;
 import com.ticketing.server.user.application.request.UserChangePasswordRequest;
 import com.ticketing.server.user.application.request.UserDeleteRequest;
+import com.ticketing.server.user.application.response.PaymentsResponse;
 import com.ticketing.server.user.application.response.SignUpResponse;
 import com.ticketing.server.user.application.response.UserChangePasswordResponse;
 import com.ticketing.server.user.application.response.UserDeleteResponse;
 import com.ticketing.server.user.application.response.UserDetailResponse;
-import com.ticketing.server.user.domain.User;
 import com.ticketing.server.user.domain.UserGrade;
-import com.ticketing.server.user.service.UserServiceImpl;
+import com.ticketing.server.user.service.dto.ChangedPasswordUserDTO;
+import com.ticketing.server.user.service.dto.DeletedUserDTO;
+import com.ticketing.server.user.service.dto.PaymentsDTO;
+import com.ticketing.server.user.service.dto.ChangePasswordDTO;
+import com.ticketing.server.user.service.dto.CreatedUserDTO;
+import com.ticketing.server.user.service.dto.UserDetailDTO;
+import com.ticketing.server.user.service.interfaces.UserApisService;
+import com.ticketing.server.user.service.interfaces.UserService;
 import javax.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -33,36 +44,62 @@ import org.springframework.web.bind.annotation.RestController;
 @Slf4j
 public class UserController {
 
-	private final UserServiceImpl userService;
+	private final UserApisService userApisService;
+	private final UserService userService;
 	private final PasswordEncoder passwordEncoder;
 
 	@PostMapping
 	public ResponseEntity<SignUpResponse> register(@RequestBody @Valid SignUpRequest request) {
-		User user = userService.register(request.toSignUpDto(passwordEncoder));
-		return ResponseEntity.status(HttpStatus.CREATED).body(SignUpResponse.from(user));
+		CreatedUserDTO createdUserDto = userService.register(request.toSignUpDto(passwordEncoder));
+
+		return ResponseEntity.status(HttpStatus.CREATED)
+			.body(createdUserDto.toResponse());
 	}
 
 	@GetMapping("/details")
-	@Secured("ROLE_GUEST")
+	@Secured(USER)
 	public ResponseEntity<UserDetailResponse> details(@AuthenticationPrincipal UserDetails userRequest) {
-		User user = userService.findByEmail(userRequest.getUsername());
-		return ResponseEntity.status(HttpStatus.OK).body(UserDetailResponse.from(user));
+		UserDetailDTO userDetail = userService.findDetailByEmail(userRequest.getUsername());
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(userDetail.toResponse());
 	}
 
 	@DeleteMapping
-	@Secured(UserGrade.ROLES.GUEST)
+	@Secured(USER)
 	public ResponseEntity<UserDeleteResponse> deleteUser(@RequestBody @Valid UserDeleteRequest request) {
-		User user = userService.delete(request.toDeleteUserDto(passwordEncoder));
-		return ResponseEntity.status(HttpStatus.OK).body(UserDeleteResponse.from(user));
+		DeletedUserDTO deletedUserDto = userService.delete(request.toDeleteUserDto(passwordEncoder));
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(deletedUserDto.toResponse());
 	}
 
 	@PutMapping("/password")
-	@Secured(UserGrade.ROLES.GUEST)
+	@Secured(USER)
 	public ResponseEntity<UserChangePasswordResponse> changePassword(
 		@AuthenticationPrincipal UserDetails userRequest,
 		@RequestBody @Valid UserChangePasswordRequest request) {
-		User user = userService.changePassword(request.toChangePasswordDto(userRequest.getUsername(), passwordEncoder));
-		return ResponseEntity.status(HttpStatus.OK).body(UserChangePasswordResponse.from(user));
+		ChangePasswordDTO changePasswordDto = request.toChangePasswordDto(userRequest.getUsername(), passwordEncoder);
+		ChangedPasswordUserDTO changedUserDto = userService.changePassword(changePasswordDto);
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(changedUserDto.toResponse());
+	}
+
+	@PostMapping("/grade")
+	@Secured(ADMIN)
+	public ResponseEntity<UserChangeGradeResponse> changeGrade(@RequestBody @Valid UserChangeGradeRequest request) {
+		ChangeGradeDTO changeGradeDto = userService.changeGrade(request.getEmail(), request.getAfterGrade());
+		return ResponseEntity.status(HttpStatus.OK).body(changeGradeDto.toResponse());
+	}
+
+	@GetMapping("/payments")
+	@Secured(USER)
+	public ResponseEntity<PaymentsResponse> getPayments(@AuthenticationPrincipal UserDetails userRequest) {
+		PaymentsDTO paymentsDto = userApisService.findPaymentsByEmail(userRequest.getUsername());
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(paymentsDto.toResponse());
 	}
 
 }

server/src/main/java/com/ticketing/server/user/application/request/UserChangeGradeRequest.java

@@ -0,0 +1,19 @@
+package com.ticketing.server.user.application.request;
+
+import com.ticketing.server.user.domain.UserGrade;
+import javax.validation.constraints.Email;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+import lombok.Getter;
+
+@Getter
+public class UserChangeGradeRequest {
+
+	@NotEmpty(message = "{validation.not.empty.email}")
+	@Email(message = "{validation.email}")
+	private String email;
+
+	@NotNull(message = "{validation.not.null.grade}")
+	private UserGrade afterGrade;
+
+}

server/src/main/java/com/ticketing/server/user/application/response/LogoutResponse.java

@@ -1,28 +1,14 @@
 package com.ticketing.server.user.application.response;
 
-import com.ticketing.server.global.redis.RefreshToken;
-import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 
 @Getter
-@AllArgsConstructor(access = AccessLevel.PRIVATE)
+@AllArgsConstructor
 public class LogoutResponse {
 
-	private Long refreshTokenId;
-	private String email;
-	private String refreshToken;
-
-	private LogoutResponse(String email) {
-		this.email = email;
-	}
-
-	public static LogoutResponse from(String email) {
-		return new LogoutResponse(email);
-	}
-
-	public static LogoutResponse from(RefreshToken refreshToken) {
-		return new LogoutResponse(refreshToken.getId(), refreshToken.getEmail(), refreshToken.getToken());
-	}
+	private final Long refreshTokenId;
+	private final String email;
+	private final String refreshToken;
 
 }

server/src/main/java/com/ticketing/server/user/application/response/PaymentsResponse.java

@@ -0,0 +1,15 @@
+package com.ticketing.server.user.application.response;
+
+import com.ticketing.server.payment.service.dto.SimplePaymentDTO;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class PaymentsResponse {
+
+	private final String email;
+	private final List<SimplePaymentDTO> payments;
+
+}

server/src/main/java/com/ticketing/server/user/application/response/SignUpResponse.java

@@ -1,20 +1,13 @@
 package com.ticketing.server.user.application.response;
 
-import com.ticketing.server.user.domain.User;
-import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 
 @Getter
-@AllArgsConstructor(access = AccessLevel.PRIVATE)
+@AllArgsConstructor
 public class SignUpResponse {
 
-	private String name;
-
-	private String email;
-
-	public static SignUpResponse from(User user) {
-		return new SignUpResponse(user.getName(), user.getEmail());
-	}
+	private final String name;
+	private final String email;
 
 }

server/src/main/java/com/ticketing/server/user/application/response/TokenDto.java

@@ -1,20 +0,0 @@
-package com.ticketing.server.user.application.response;
-
-import lombok.AccessLevel;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-
-@Getter
-@AllArgsConstructor(access = AccessLevel.PRIVATE)
-public class TokenDto {
-
-	private final String accessToken;
-	private final String refreshToken;
-	private final String tokenType;
-	private final long expiresIn;
-
-	public static TokenDto of(String accessToken, String refreshToken, String tokenType, long expiresIn) {
-		return new TokenDto(accessToken, refreshToken, tokenType, expiresIn);
-	}
-
-}

server/src/main/java/com/ticketing/server/user/application/response/TokenResponse.java

@@ -0,0 +1,15 @@
+package com.ticketing.server.user.application.response;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class TokenResponse {
+
+	private final String accessToken;
+	private final String refreshToken;
+	private final String tokenType;
+	private final long expiresIn;
+
+}

server/src/main/java/com/ticketing/server/user/application/response/UserChangePasswordResponse.java

@@ -1,20 +1,15 @@
 package com.ticketing.server.user.application.response;
 
-import com.ticketing.server.user.domain.User;
-import lombok.AccessLevel;
+import java.time.LocalDateTime;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 
 @Getter
-@AllArgsConstructor(access = AccessLevel.PRIVATE)
+@AllArgsConstructor
 public class UserChangePasswordResponse {
 
-	private String name;
-
-	private String email;
-
-	public static UserChangePasswordResponse from(User user) {
-		return new UserChangePasswordResponse(user.getName(), user.getEmail());
-	}
+	private final String name;
+	private final String email;
+	private final LocalDateTime updatedAt;
 
 }

server/src/main/java/com/ticketing/server/user/application/response/UserDeleteResponse.java

@@ -1,20 +1,15 @@
 package com.ticketing.server.user.application.response;
 
-import com.ticketing.server.user.domain.User;
-import lombok.AccessLevel;
+import java.time.LocalDateTime;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 
 @Getter
-@AllArgsConstructor(access = AccessLevel.PRIVATE)
+@AllArgsConstructor
 public class UserDeleteResponse {
 
-	private String name;
-
-	private String email;
-
-	public static UserDeleteResponse from(User user) {
-		return new UserDeleteResponse(user.getName(), user.getEmail());
-	}
+	private final String name;
+	private final String email;
+	private final LocalDateTime deletedAt;
 
 }

server/src/main/java/com/ticketing/server/user/application/response/UserDetailResponse.java

@@ -1,7 +1,8 @@
 package com.ticketing.server.user.application.response;
 
-import com.ticketing.server.user.domain.User;
 import com.ticketing.server.user.domain.UserGrade;
+import com.ticketing.server.user.service.dto.UserDetailDTO;
+import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 
@@ -9,13 +10,9 @@ import lombok.Getter;
 @AllArgsConstructor
 public class UserDetailResponse {
 
-	private String name;
-	private String email;
-	private UserGrade grade;
-	private String phone;
-
-	public static UserDetailResponse from(User user) {
-		return new UserDetailResponse(user.getName(), user.getEmail(), user.getGrade(), user.getPhone());
-	}
+	private final String name;
+	private final String email;
+	private final UserGrade grade;
+	private final String phone;
 
 }

server/src/main/java/com/ticketing/server/user/domain/ChangeGradeDTO.java

@@ -0,0 +1,19 @@
+package com.ticketing.server.user.domain;
+
+import com.ticketing.server.user.application.UserChangeGradeResponse;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class ChangeGradeDTO {
+
+	private final String email;
+	private final UserGrade beforeGrade;
+	private final UserGrade afterGrade;
+
+	public UserChangeGradeResponse toResponse() {
+		return new UserChangeGradeResponse(email, beforeGrade, afterGrade);
+	}
+
+}

server/src/main/java/com/ticketing/server/user/domain/SequenceGenerator.java

@@ -0,0 +1,9 @@
+package com.ticketing.server.user.domain;
+
+public interface SequenceGenerator {
+
+	Long generateId();
+
+	long[] parse(long id);
+
+}

server/src/main/java/com/ticketing/server/user/domain/Snowflake.java

@@ -0,0 +1,118 @@
+package com.ticketing.server.user.domain;
+
+import java.net.NetworkInterface;
+import java.security.SecureRandom;
+import java.time.Instant;
+import java.util.Enumeration;
+import org.springframework.stereotype.Component;
+
+/**
+ * Twitter Snowflake Custom.
+ * https://github.com/callicoder/java-snowflake
+ */
+@Component
+public class Snowflake implements SequenceGenerator {
+
+	private static final int EPOCH_BITS = 41;
+	private static final int NODE_ID_BITS = 10;
+	private static final int SEQUENCE_BITS = 12;
+
+	private static final long MAX_NODE_ID = (1L << NODE_ID_BITS) - 1;
+	private static final long MAX_SEQUENCE = (1L << SEQUENCE_BITS) - 1;
+
+	// Custom Epoch (January 1, 2015 Midnight UTC = 2015-01-01T00:00:00Z)
+	private static final long DEFAULT_CUSTOM_EPOCH = 1420070400000L;
+
+	private final long nodeId;
+	private final long customEpoch;
+
+	private volatile long lastTimestamp = -1L;
+	private volatile long sequence = 0L;
+
+	// Let Snowflake generate a nodeId
+	public Snowflake() {
+		this.nodeId = createNodeId();
+		this.customEpoch = DEFAULT_CUSTOM_EPOCH;
+	}
+
+	@Override
+	public Long generateId() {
+		return nextId();
+	}
+
+	private synchronized long nextId() {
+		long currentTimestamp = timestamp();
+
+		if(currentTimestamp < lastTimestamp) {
+			throw new IllegalStateException("Invalid System Clock!");
+		}
+
+		if (currentTimestamp == lastTimestamp) {
+			sequence = (sequence + 1) & MAX_SEQUENCE;
+			if(sequence == 0) {
+				// 동일 밀리초 시퀀스가 소진됐을 경우 대기.
+				currentTimestamp = waitNextMillis(currentTimestamp);
+			}
+		} else {
+			// 다음 밀리초 시퀀스 초기화.
+			sequence = 0;
+		}
+
+		lastTimestamp = currentTimestamp;
+		return currentTimestamp << (NODE_ID_BITS + SEQUENCE_BITS)
+			| (nodeId << SEQUENCE_BITS)
+			| sequence;
+	}
+
+	public long[] parse(long id) {
+		long maskNodeId = ((1L << NODE_ID_BITS) - 1) << SEQUENCE_BITS;
+		long maskSequence = (1L << SEQUENCE_BITS) - 1;
+
+		long timestamp = (id >> (NODE_ID_BITS + SEQUENCE_BITS)) + customEpoch;
+		long nodeId = (id & maskNodeId) >> SEQUENCE_BITS;
+		long sequence = id & maskSequence;
+
+		return new long[]{timestamp, nodeId, sequence};
+	}
+
+	private long timestamp() {
+		return Instant.now().toEpochMilli() - customEpoch;
+	}
+
+	private long waitNextMillis(long currentTimestamp) {
+		while (currentTimestamp == lastTimestamp) {
+			currentTimestamp = timestamp();
+		}
+		return currentTimestamp;
+	}
+
+	private long createNodeId() {
+		long nodeId;
+		try {
+			StringBuilder sb = new StringBuilder();
+			Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
+			while (networkInterfaces.hasMoreElements()) {
+				NetworkInterface networkInterface = networkInterfaces.nextElement();
+				byte[] mac = networkInterface.getHardwareAddress();
+				if (mac != null) {
+					for(byte macPort: mac) {
+						sb.append(String.format("%02X", macPort));
+					}
+				}
+			}
+			nodeId = sb.toString().hashCode();
+		} catch (Exception ex) {
+			nodeId = (new SecureRandom().nextInt());
+		}
+		nodeId = nodeId & MAX_NODE_ID;
+		return nodeId;
+	}
+
+	@Override
+	public String toString() {
+		return "Snowflake Settings [EPOCH_BITS=" + EPOCH_BITS + ", NODE_ID_BITS=" + NODE_ID_BITS
+			+ ", SEQUENCE_BITS=" + SEQUENCE_BITS + ", CUSTOM_EPOCH=" + customEpoch
+			+ ", NodeId=" + nodeId + "]";
+	}
+
+}

server/src/main/java/com/ticketing/server/user/domain/User.java

@@ -1,10 +1,7 @@
 package com.ticketing.server.user.domain;
 
-import static com.ticketing.server.global.exception.ErrorCode.DELETED_EMAIL;
-import static com.ticketing.server.global.exception.ErrorCode.MISMATCH_PASSWORD;
-
 import com.ticketing.server.global.dto.repository.AbstractEntity;
-import com.ticketing.server.global.exception.TicketingException;
+import com.ticketing.server.global.exception.ErrorCode;
 import com.ticketing.server.global.validator.constraints.Phone;
 import com.ticketing.server.user.service.dto.ChangePasswordDTO;
 import com.ticketing.server.user.service.dto.DeleteUserDTO;
@@ -17,42 +14,54 @@ import javax.persistence.Enumerated;
 import javax.validation.constraints.Email;
 import javax.validation.constraints.NotEmpty;
 import javax.validation.constraints.NotNull;
+import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 
 @Entity
 @Getter
-@NoArgsConstructor
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class User extends AbstractEntity {
 
-	@Column(name = "name")
+	@Column(name = "alternate_key", unique = true, nullable = false)
+	@NotNull(message = "{validation.not.null.alternate.key}")
+	private Long alternateId;
+
+	@Column(name = "name", nullable = false)
 	@NotEmpty(message = "{validation.not.empty.name}")
 	private String name;
 
-	@Column(name = "email")
+	@Column(name = "email", unique = true, nullable = false)
 	@NotEmpty(message = "{validation.not.empty.email}")
 	@Email(message = "{validation.email}")
 	private String email;
 
-	@Column(name = "password")
+	@Column(name = "password", nullable = false)
 	@NotEmpty(message = "{validation.not.empty.password}")
 	private String password;
 
-	@Column(name = "grade")
-	@NotNull(message = "{validation.not.empty.grade}")
+	@Column(name = "grade", nullable = false)
+	@NotNull(message = "{validation.not.null.grade}")
 	@Enumerated(value = EnumType.STRING)
-	private UserGrade grade = UserGrade.GUEST;
+	private UserGrade grade = UserGrade.USER;
 
-	@Column(name = "phone")
+	@Column(name = "phone", nullable = false)
 	@NotEmpty(message = "{validation.not.empty.phone}")
 	@Phone
 	private String phone;
 
-	private boolean isDeleted = false;
+	public User(Long alternateId, String name, String email, String password, UserGrade grade, String phone) {
+		this.alternateId = alternateId;
+		this.name = name;
+		this.email = email;
+		this.password = password;
+		this.grade = grade;
+		this.phone = phone;
+	}
 
-	private LocalDateTime deletedAt;
-
-	public User(String name, String email, String password, UserGrade grade, String phone) {
+	User(Long id, Long alternateId, String name, String email, String password, UserGrade grade, String phone) {
+		this.id = id;
+		this.alternateId = alternateId;
 		this.name = name;
 		this.email = email;
 		this.password = password;
@@ -61,13 +70,12 @@ public class User extends AbstractEntity {
 	}
 
 	public User delete(DeleteUserDTO deleteUser) {
-		if (isDeleted) {
-			throw new TicketingException(DELETED_EMAIL);
+		if (deletedAt != null) {
+			throw ErrorCode.throwDeletedEmail();
 		}
 
 		checkPassword(deleteUser);
 
-		isDeleted = true;
 		deletedAt = LocalDateTime.now();
 		return this;
 	}
@@ -81,8 +89,18 @@ public class User extends AbstractEntity {
 
 	public void checkPassword(PasswordMatches passwordMatches) {
 		if (!passwordMatches.passwordMatches(password)) {
-			throw new TicketingException(MISMATCH_PASSWORD);
+			throw ErrorCode.throwMismatchPassword();
 		}
 	}
 
+	public ChangeGradeDTO changeGrade(UserGrade afterGrade) {
+		if (grade.equals(afterGrade)) {
+			throw ErrorCode.throwUnableChangeGrade();
+		}
+		final UserGrade beforeGrade = this.grade;
+
+		this.grade = afterGrade;
+		return new ChangeGradeDTO(email, beforeGrade, afterGrade);
+	}
+
 }

server/src/main/java/com/ticketing/server/user/domain/UserGrade.java

@@ -6,7 +6,7 @@ import lombok.RequiredArgsConstructor;
 public enum UserGrade {
 	ADMIN(ROLES.ADMIN, null),
 	STAFF(ROLES.STAFF, ROLES.ADMIN),
-	GUEST(ROLES.GUEST, ROLES.STAFF);
+	USER(ROLES.USER, ROLES.STAFF);
 
 	private final String roleName;
 	private final String parentName;
@@ -15,7 +15,7 @@ public enum UserGrade {
 
 		public static final String ADMIN = "ROLE_ADMIN";
 		public static final String STAFF = "ROLE_STAFF";
-		public static final String GUEST = "ROLE_GUEST";
+		public static final String USER = "ROLE_USER";
 
 		private ROLES() {
 		}

server/src/main/java/com/ticketing/server/user/domain/repository/UserRepository.java

@@ -10,6 +10,6 @@ public interface UserRepository extends JpaRepository<User, Long> {
 
 	Optional<User> findByEmail(String email);
 
-	Optional<User> findByEmailAndIsDeletedFalse(String email);
+	Optional<User> findByEmailAndDeletedAtNull(String email);
 
 }

server/src/main/java/com/ticketing/server/user/service/AuthenticationServiceImpl.java

@@ -1,16 +1,12 @@
 package com.ticketing.server.user.service;
 
-import static com.ticketing.server.global.exception.ErrorCode.REFRESH_TOKEN_NOT_FOUND;
-import static com.ticketing.server.global.exception.ErrorCode.TOKEN_TYPE;
-import static com.ticketing.server.global.exception.ErrorCode.UNAVAILABLE_REFRESH_TOKEN;
-
-import com.ticketing.server.global.exception.TicketingException;
+import com.ticketing.server.global.exception.ErrorCode;
 import com.ticketing.server.global.redis.RefreshRedisRepository;
 import com.ticketing.server.global.redis.RefreshToken;
 import com.ticketing.server.global.security.jwt.JwtProperties;
 import com.ticketing.server.global.security.jwt.JwtProvider;
-import com.ticketing.server.user.application.response.LogoutResponse;
-import com.ticketing.server.user.application.response.TokenDto;
+import com.ticketing.server.user.service.dto.TokenDTO;
+import com.ticketing.server.user.service.dto.DeleteRefreshTokenDTO;
 import com.ticketing.server.user.service.interfaces.AuthenticationService;
 import lombok.RequiredArgsConstructor;
 import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
@@ -32,14 +28,14 @@ public class AuthenticationServiceImpl implements AuthenticationService {
 
 	@Override
 	@Transactional
-	public TokenDto generateTokenDto(UsernamePasswordAuthenticationToken authenticationToken) {
+	public TokenDTO generateTokenDto(UsernamePasswordAuthenticationToken authenticationToken) {
 		// 회원인증
 		Authentication authentication = authenticationManagerBuilder.getObject().authenticate(authenticationToken);
 
 		String email = authenticationToken.getName();
 
 		// 토큰 발급
-		TokenDto tokenDto = jwtProvider.generateTokenDto(authentication);
+		TokenDTO tokenDto = jwtProvider.generateTokenDto(authentication);
 
 		// refresh 토큰이 있으면 수정, 없으면 생성
 		refreshRedisRepository.findByEmail(email)
@@ -53,7 +49,7 @@ public class AuthenticationServiceImpl implements AuthenticationService {
 
 	@Override
 	@Transactional
-	public TokenDto reissueTokenDto(String bearerRefreshToken) {
+	public TokenDTO reissueTokenDto(String bearerRefreshToken) {
 		String refreshToken = resolveToken(bearerRefreshToken);
 
 		// 토큰 검증
@@ -63,15 +59,15 @@ public class AuthenticationServiceImpl implements AuthenticationService {
 
 		// Redis 에 토큰이 있는지 검증
 		RefreshToken findTokenEntity = refreshRedisRepository.findByEmail(authentication.getName())
-			.orElseThrow(() -> new TicketingException(REFRESH_TOKEN_NOT_FOUND));
+			.orElseThrow(ErrorCode::throwRefreshTokenNotFound);
 
 		// redis 토큰과 input 토큰이 일치한지 확인
 		if (!refreshToken.equals(findTokenEntity.getToken())) {
-			throw new TicketingException(UNAVAILABLE_REFRESH_TOKEN);
+			throw ErrorCode.throwUnavailableRefreshToken();
 		}
 
 		// 토큰 발급
-		TokenDto tokenDto = jwtProvider.generateTokenDto(authentication);
+		TokenDTO tokenDto = jwtProvider.generateTokenDto(authentication);
 
 		// 토큰 최신화
 		findTokenEntity.changeToken(tokenDto.getRefreshToken());
@@ -82,19 +78,21 @@ public class AuthenticationServiceImpl implements AuthenticationService {
 
 	@Override
 	@Transactional
-	public LogoutResponse deleteRefreshToken(String email) {
+	public DeleteRefreshTokenDTO deleteRefreshToken(String email) {
 		return refreshRedisRepository.findByEmail(email)
 			.map(tokenDto -> {
 				refreshRedisRepository.delete(tokenDto);
-				return LogoutResponse.from(tokenDto);
-			}).orElseGet(() -> LogoutResponse.from(email));
+				return new DeleteRefreshTokenDTO(tokenDto);
+			}).orElseGet(
+				() -> new DeleteRefreshTokenDTO(email)
+			);
 	}
 
 	private String resolveToken(String bearerToken) {
 		if (StringUtils.hasText(bearerToken) && jwtProperties.hasTokenStartsWith(bearerToken)) {
 			return bearerToken.substring(7);
 		}
-		throw new TicketingException(TOKEN_TYPE);
+		throw ErrorCode.throwTokenType();
 	}
 
 }

server/src/main/java/com/ticketing/server/user/service/CustomUserDetailsService.java

@@ -1,8 +1,6 @@
 package com.ticketing.server.user.service;
 
-import static com.ticketing.server.global.exception.ErrorCode.EMAIL_NOT_FOUND;
-
-import com.ticketing.server.global.exception.TicketingException;
+import com.ticketing.server.global.exception.ErrorCode;
 import com.ticketing.server.user.domain.User;
 import com.ticketing.server.user.domain.repository.UserRepository;
 import java.util.Collections;
@@ -21,9 +19,9 @@ public class CustomUserDetailsService implements UserDetailsService {
 
 	@Override
 	public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
-		return userRepository.findByEmailAndIsDeletedFalse(email)
+		return userRepository.findByEmailAndDeletedAtNull(email)
 			.map(this::createUserDetails)
-			.orElseThrow(() -> new TicketingException(EMAIL_NOT_FOUND));
+			.orElseThrow(ErrorCode::throwEmailNotFound);
 	}
 
 	private UserDetails createUserDetails(User user) {
@@ -35,4 +33,5 @@ public class CustomUserDetailsService implements UserDetailsService {
 			, Collections.singleton(grantedAuthority)
 		);
 	}
+
 }

server/src/main/java/com/ticketing/server/user/service/UserApisServiceImpl.java

@@ -0,0 +1,34 @@
+package com.ticketing.server.user.service;
+
+import com.ticketing.server.payment.application.response.SimplePaymentsResponse;
+import com.ticketing.server.user.api.PaymentClient;
+import com.ticketing.server.user.domain.User;
+import com.ticketing.server.user.service.dto.PaymentsDTO;
+import com.ticketing.server.user.service.interfaces.UserApisService;
+import com.ticketing.server.user.service.interfaces.UserService;
+import javax.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.validation.annotation.Validated;
+
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+@Validated
+@Slf4j
+public class UserApisServiceImpl implements UserApisService {
+
+	private final PaymentClient paymentClient;
+	private final UserService userService;
+
+	@Override
+	public PaymentsDTO findPaymentsByEmail(@NotNull String email) {
+		User user = userService.findNotDeletedUserByEmail(email);
+		SimplePaymentsResponse simplePayments = paymentClient.getPayments(user.getAlternateId());
+
+		return new PaymentsDTO(user, simplePayments);
+	}
+
+}

server/src/main/java/com/ticketing/server/user/service/UserServiceImpl.java

@@ -1,17 +1,22 @@
 package com.ticketing.server.user.service;
 
-import static com.ticketing.server.global.exception.ErrorCode.DUPLICATE_EMAIL;
-import static com.ticketing.server.global.exception.ErrorCode.EMAIL_NOT_FOUND;
-
-import com.ticketing.server.global.exception.TicketingException;
+import com.ticketing.server.global.exception.ErrorCode;
+import com.ticketing.server.user.domain.ChangeGradeDTO;
+import com.ticketing.server.user.domain.SequenceGenerator;
 import com.ticketing.server.user.domain.User;
+import com.ticketing.server.user.domain.UserGrade;
 import com.ticketing.server.user.domain.repository.UserRepository;
 import com.ticketing.server.user.service.dto.ChangePasswordDTO;
+import com.ticketing.server.user.service.dto.ChangedPasswordUserDTO;
+import com.ticketing.server.user.service.dto.CreatedUserDTO;
 import com.ticketing.server.user.service.dto.DeleteUserDTO;
+import com.ticketing.server.user.service.dto.DeletedUserDTO;
 import com.ticketing.server.user.service.dto.SignUpDTO;
+import com.ticketing.server.user.service.dto.UserDetailDTO;
 import com.ticketing.server.user.service.interfaces.UserService;
 import java.util.Optional;
 import javax.validation.Valid;
+import javax.validation.constraints.NotNull;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
@@ -26,45 +31,57 @@ import org.springframework.validation.annotation.Validated;
 public class UserServiceImpl implements UserService {
 
 	private final UserRepository userRepository;
+	private final SequenceGenerator sequenceGenerator;
 
 	@Override
 	@Transactional
-	public User register(@Valid SignUpDTO signUpDto) {
-		Optional<User> user = userRepository.findByEmail(signUpDto.getEmail());
-		if (user.isEmpty()) {
-			return userRepository.save(signUpDto.toUser());
+	public CreatedUserDTO register(@Valid SignUpDTO signUpDto) {
+		Optional<User> optionalUser = userRepository.findByEmail(signUpDto.getEmail());
+		if (optionalUser.isEmpty()) {
+			User user = userRepository.save(signUpDto.toUser(sequenceGenerator.generateId()));
+			return new CreatedUserDTO(user);
 		}
 
-		throw new TicketingException(DUPLICATE_EMAIL);
+		throw ErrorCode.throwDuplicateEmail();
 	}
 
 	@Override
 	@Transactional
-	public User delete(@Valid DeleteUserDTO deleteUserDto) {
-		User user = findNotDeletedUserByEmail(deleteUserDto.getEmail());
-		return user.delete(deleteUserDto);
+	public DeletedUserDTO delete(@Valid DeleteUserDTO deleteUserDto) {
+		User user = findNotDeletedUserByEmail(deleteUserDto.getEmail())
+			.delete(deleteUserDto);
+
+		return new DeletedUserDTO(user);
 	}
 
 	@Override
 	@Transactional
-	public User changePassword(@Valid ChangePasswordDTO changePasswordDto) {
-		User user = findNotDeletedUserByEmail(changePasswordDto.getEmail());
-		return user.changePassword(changePasswordDto);
+	public ChangedPasswordUserDTO changePassword(@Valid ChangePasswordDTO changePasswordDto) {
+		User user = findNotDeletedUserByEmail(changePasswordDto.getEmail())
+			.changePassword(changePasswordDto);
+
+		return new ChangedPasswordUserDTO(user);
 	}
 
 	@Override
-	public User findByEmail(String email) {
-		return userRepository.findByEmail(email)
-			.orElseThrow(UserServiceImpl::throwEmailNotFound);
+	@Transactional
+	public ChangeGradeDTO changeGrade(@NotNull String email, @NotNull UserGrade grade) {
+		User user = findNotDeletedUserByEmail(email);
+		return user.changeGrade(grade);
 	}
 
-	private User findNotDeletedUserByEmail(String email) {
-		return userRepository.findByEmailAndIsDeletedFalse(email)
-			.orElseThrow(UserServiceImpl::throwEmailNotFound);
+	@Override
+	public UserDetailDTO findDetailByEmail(@NotNull String email) {
+		User user = userRepository.findByEmail(email)
+			.orElseThrow(ErrorCode::throwEmailNotFound);
+
+		return new UserDetailDTO(user);
 	}
 
-	private static RuntimeException throwEmailNotFound() {
-		throw new TicketingException(EMAIL_NOT_FOUND);
+	@Override
+	public User findNotDeletedUserByEmail(@NotNull String email) {
+		return userRepository.findByEmailAndDeletedAtNull(email)
+			.orElseThrow(ErrorCode::throwEmailNotFound);
 	}
 
 }