fix: 공백 탭으로 변경

* refactor: set movie title unique -> not unique

* add: findValidMovieWithTitle() in MovieRepository

* refactor: changed MovieTitleResponse -> MovieInfoResponse

* refactor: register Movie API

* add: throwDeletedMovie() exception

* add: deleteMovie() in movieService

* refactor: get movie list API

* refactor: movieService test code

* feat: delete movie API

README.md

@@ -37,6 +37,7 @@
 - [패키지 구조](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)
+- [Issue Posting](https://github.com/f-lab-edu/Ticketing/wiki/Issue-Posting)
 
 <br/>
 

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

@@ -28,12 +28,15 @@ public enum ErrorCode {
 	MOVIE_NOT_FOUND(NOT_FOUND, "해당 제목의 영화를 찾을 수 없습니다."),
 	REFRESH_TOKEN_NOT_FOUND(NOT_FOUND, "리프레쉬 토큰을 찾을 수 없습니다."),
 	PAYMENT_ID_NOT_FOUND(NOT_FOUND, "결제정보를 찾을 수 없습니다."),
+	THEATER_NOT_FOUND(NOT_FOUND, "상영관 정보를 찾을 수 없습니다."),
 
 	/* 409 CONFLICT : Resource 의 현재 상태와 충돌. 보통 중복된 데이터 존재 */
 	DUPLICATE_EMAIL(CONFLICT, "이메일이 이미 존재합니다."),
 	DUPLICATE_PAYMENT(CONFLICT, "해당 좌석은 현재 판매된 좌석입니다."),
 	DUPLICATE_MOVIE(CONFLICT, "해당 영화 정보가 이미 존재합니다."),
-	DELETED_EMAIL(CONFLICT, "이미 삭제된 이메일 입니다.");
+	DUPLICATE_MOVIE_TIME(CONFLICT, "해당 영화 시간표 정보가 이미 존재합니다."),
+	DELETED_EMAIL(CONFLICT, "이미 삭제된 이메일 입니다."),
+	DELETED_MOVIE(CONFLICT, "이미 삭제된 영화 입니다.");
 
 	private final HttpStatus httpStatus;
 	private final String detail;
@@ -81,6 +84,10 @@ public enum ErrorCode {
 		throw new TicketingException(PAYMENT_ID_NOT_FOUND);
 	}
 
+	public static TicketingException throwTheaterNotFound() {
+		throw new TicketingException(THEATER_NOT_FOUND);
+	}
+
 	/* 409 CONFLICT : Resource 의 현재 상태와 충돌. 보통 중복된 데이터 존재 */
 	public static TicketingException throwDuplicateEmail() {
 		throw new TicketingException(DUPLICATE_EMAIL);
@@ -94,8 +101,16 @@ public enum ErrorCode {
 		throw new TicketingException(DUPLICATE_MOVIE);
 	}
 
+	public static TicketingException throwDuplicateMovieTime() {
+		throw new TicketingException(DUPLICATE_MOVIE_TIME);
+	}
+
 	public static TicketingException throwDeletedEmail() {
 		throw new TicketingException(DELETED_EMAIL);
 	}
 
+	public static TicketingException throwDeletedMovie() {
+		throw new TicketingException(DELETED_MOVIE);
+	}
+
 }

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/movie/application/MovieController.java

@@ -1,8 +1,15 @@
 package com.ticketing.server.movie.application;
 
+import static com.ticketing.server.user.domain.UserGrade.ROLES.STAFF;
+
+import com.ticketing.server.movie.application.request.MovieDeleteRequest;
 import com.ticketing.server.movie.application.request.MovieRegisterRequest;
+import com.ticketing.server.movie.application.response.MovieDeleteResponse;
 import com.ticketing.server.movie.application.response.MovieListResponse;
-import com.ticketing.server.movie.application.response.MovieTitleResponse;
+import com.ticketing.server.movie.application.response.MovieInfoResponse;
+import com.ticketing.server.movie.service.dto.DeletedMovieDTO;
+import com.ticketing.server.movie.service.dto.MovieListDTO;
+import com.ticketing.server.movie.service.dto.RegisteredMovieDTO;
 import com.ticketing.server.movie.service.interfaces.MovieService;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
@@ -12,6 +19,7 @@ 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.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -29,25 +37,37 @@ public class MovieController {
 
 	@PostMapping()
 	@ApiOperation(value = "영화 정보 등록")
-	@Secured("ROLE_STAFF")
-	public ResponseEntity<MovieTitleResponse> registerMovie(@RequestBody @Valid MovieRegisterRequest request) {
+	@Secured(STAFF)
+	public ResponseEntity<MovieInfoResponse> registerMovie(@RequestBody @Valid MovieRegisterRequest request) {
+		RegisteredMovieDTO registeredMovieDto =
+			movieService.registerMovie(request.getTitle(), request.getRunningTime());
+
 		return ResponseEntity.status(HttpStatus.OK)
 			.body(
-				MovieTitleResponse.from(
-					movieService.registerMovie(request.toMovieRegisterDTO())
-				)
+				registeredMovieDto.toResponse()
 			);
 	}
 
 	@GetMapping()
 	@ApiOperation(value = "영화 목록 조회")
 	public ResponseEntity<MovieListResponse> getMovies() {
+		MovieListDTO movieListDto = movieService.getMovies();
+
 		return ResponseEntity.status(HttpStatus.OK)
 			.body(
-				MovieListResponse.from(
-					movieService.getMovies()
-				)
+				movieListDto.toResponse()
 			);
 	}
 
+	@DeleteMapping()
+	@ApiOperation(value = "영화 정보 삭제")
+	@Secured(STAFF)
+	public ResponseEntity<MovieDeleteResponse> deleteMovie(@RequestBody @Valid MovieDeleteRequest request) {
+		DeletedMovieDTO deletedMovieDto = movieService.deleteMovie(request.getId());
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(
+				deletedMovieDto.toResponse()
+			);
+	}
 }

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

@@ -1,18 +1,29 @@
 package com.ticketing.server.movie.application;
 
+import static com.ticketing.server.user.domain.UserGrade.ROLES.STAFF;
+
+import com.ticketing.server.movie.application.request.MovieTimeRegisterRequest;
+import com.ticketing.server.movie.application.response.MovieTimeInfoResponse;
 import com.ticketing.server.movie.application.response.MovieTimeListResponse;
+import com.ticketing.server.movie.service.dto.MovieTimeListDTO;
+import com.ticketing.server.movie.service.dto.RegisteredMovieTimeDTO;
 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 javax.validation.Valid;
+import javax.validation.constraints.NotNull;
 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.security.access.annotation.Secured;
 import org.springframework.validation.annotation.Validated;
 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.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
@@ -24,16 +35,35 @@ import org.springframework.web.bind.annotation.RestController;
 @Slf4j
 public class MovieTimeController {
 
-    private final MovieTimeService movieTimeService;
+	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)));
-    }
+	@PostMapping
+	@ApiOperation(value = "영화 시간표 등록")
+	@Secured(STAFF)
+	public ResponseEntity<MovieTimeInfoResponse> registerMovieTime(
+		@RequestBody @Valid MovieTimeRegisterRequest movieTimeRegisterRequest) {
+		RegisteredMovieTimeDTO registeredMovieTimeDto = movieTimeService.registerMovieTime(
+			movieTimeRegisterRequest.toMovieTimeRegisterDTO()
+		);
 
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(
+				registeredMovieTimeDto.toResponse()
+			);
+	}
+
+	@GetMapping
+	@ApiOperation(value = "영화 시간표 조회")
+	@Validated
+	public ResponseEntity<MovieTimeListResponse> getMovieTimes(
+		@ApiParam(value = "영화 ID", required = true) @RequestParam @NotNull Long movieId,
+		@ApiParam(value = "상영 날짜", required = true) @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate runningDate) {
+		MovieTimeListDTO movieTimeListDto = movieTimeService.getMovieTimes(movieId, runningDate);
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(
+				movieTimeListDto.toResponse()
+			);
+	}
 
 }

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

@@ -0,0 +1,16 @@
+package com.ticketing.server.movie.application.request;
+
+import javax.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@NoArgsConstructor
+@AllArgsConstructor
+public class MovieDeleteRequest {
+
+	@NotNull(message = "{validation.not.null.id}")
+	private Long id;
+
+}

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

@@ -5,10 +5,8 @@ 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 {
 
@@ -19,7 +17,7 @@ public class MovieRegisterRequest {
 	private Long runningTime;
 
 	public MovieRegisterDTO toMovieRegisterDTO() {
-		return new MovieRegisterDTO(this.title, this.runningTime);
+		return new MovieRegisterDTO(title, runningTime);
 	}
 
 }

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

@@ -0,0 +1,29 @@
+package com.ticketing.server.movie.application.request;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.ticketing.server.movie.service.dto.MovieTimeRegisterDTO;
+import java.time.LocalDateTime;
+import javax.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class MovieTimeRegisterRequest {
+
+	@NotNull(message = "{validation.not.null.movieId}")
+	private Long movieId;
+
+	@NotNull(message = "{validation.not.null.theaterNumber}")
+	private Integer theaterNumber;
+
+	@NotNull(message = "{validation.not.null.round}")
+	private Integer round;
+
+	private LocalDateTime startAt;
+
+	public MovieTimeRegisterDTO toMovieTimeRegisterDTO() {
+		return new MovieTimeRegisterDTO(movieId, theaterNumber, round, startAt);
+	}
+
+}

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

@@ -0,0 +1,17 @@
+package com.ticketing.server.movie.application.response;
+
+import java.time.LocalDateTime;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class MovieDeleteResponse {
+
+	private final Long id;
+
+	private final String title;
+
+	private final LocalDateTime deletedAt;
+
+}

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

@@ -0,0 +1,17 @@
+package com.ticketing.server.movie.application.response;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class MovieInfoResponse {
+
+	@ApiModelProperty(value = "영화 ID")
+	private Long movieId;
+
+	@ApiModelProperty(value = "영화 제목")
+	private String title;
+
+}

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

@@ -3,19 +3,14 @@ package com.ticketing.server.movie.application.response;
 import com.ticketing.server.movie.service.dto.MovieDTO;
 import io.swagger.annotations.ApiModelProperty;
 import java.util.List;
-import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 
 @Getter
-@AllArgsConstructor(access = AccessLevel.PRIVATE)
+@AllArgsConstructor
 public class MovieListResponse {
 
     @ApiModelProperty(value = "영화 제목")
     private List<MovieDTO> movieDtos;
 
-    public static MovieListResponse from(List<MovieDTO> movieDtos) {
-        return new MovieListResponse(movieDtos);
-    }
-
 }

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

@@ -0,0 +1,28 @@
+package com.ticketing.server.movie.application.response;
+
+import io.swagger.annotations.ApiModelProperty;
+import java.time.LocalDateTime;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class MovieTimeInfoResponse {
+
+	@ApiModelProperty(value = "영화 시간표 ID")
+	private Long movieTimeId;
+
+	@ApiModelProperty(value = "상영관 번호")
+	private Integer theaterNumber;
+
+	@ApiModelProperty(value = "회차")
+	private Integer round;
+
+	@ApiModelProperty(value = "시작 시간")
+	private LocalDateTime startAt;
+
+	@ApiModelProperty(value = "종료 시간")
+	private LocalDateTime endAt;
+
+
+}

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

@@ -8,14 +8,10 @@ import lombok.AllArgsConstructor;
 import lombok.Getter;
 
 @Getter
-@AllArgsConstructor(access = AccessLevel.PRIVATE)
+@AllArgsConstructor
 public class MovieTimeListResponse {
 
     @ApiModelProperty(value = "영화 시간표 정보")
-    private List<MovieTimeDTO> movieTimeDTOS;
-
-    public static MovieTimeListResponse from(List<MovieTimeDTO> movieTimeDtos) {
-        return new MovieTimeListResponse(movieTimeDtos);
-    }
+    private List<MovieTimeDTO> movieTimeDtos;
 
 }

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

@@ -1,20 +0,0 @@
-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

@@ -1,6 +1,6 @@
 package com.ticketing.server.movie.application.response;
 
-import com.ticketing.server.payment.application.response.TicketDetailDTO;
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
 import java.util.List;
 import lombok.Getter;
 

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

@@ -1,7 +1,9 @@
 package com.ticketing.server.movie.domain;
 
 import com.ticketing.server.global.dto.repository.AbstractEntity;
-import javax.persistence.Column;
+import com.ticketing.server.global.exception.ErrorCode;
+import com.ticketing.server.movie.service.dto.MovieDTO;
+import java.time.LocalDateTime;
 import javax.persistence.Entity;
 import javax.validation.constraints.NotNull;
 import lombok.AccessLevel;
@@ -16,7 +18,6 @@ import lombok.NoArgsConstructor;
 public class Movie extends AbstractEntity {
 
 	@NotNull
-	@Column(unique = true)
 	private String title;
 
 	@NotNull
@@ -28,4 +29,18 @@ public class Movie extends AbstractEntity {
 		this.runningTime = runningTime;
 	}
 
+	public Movie delete() {
+		if (deletedAt != null) {
+			throw ErrorCode.throwDeletedMovie();
+		}
+
+		deletedAt = LocalDateTime.now();
+
+		return this;
+	}
+
+	public MovieDTO toMovieDTO() {
+		return new MovieDTO(this.id, this.title);
+	}
+
 }

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

@@ -1,6 +1,8 @@
 package com.ticketing.server.movie.domain;
 
+
 import com.ticketing.server.global.dto.repository.AbstractEntity;
+import com.ticketing.server.movie.service.dto.MovieTimeDTO;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.List;
@@ -72,4 +74,9 @@ public class MovieTime extends AbstractEntity {
 		return this.theater.getSeats();
 	}
 
+	public MovieTimeDTO toMovieTimeDTO() {
+		return new MovieTimeDTO(
+			this.id, this.theater.getTheaterNumber(), this.round, this.startAt, this.endAt);
+	}
+
 }

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

@@ -13,6 +13,14 @@ public interface MovieRepository extends JpaRepository<Movie, Long> {
 
     Optional<Movie> findByTitle(String title);
 
+	Optional<Movie> findByIdAndDeletedAtNull(Long id);
+
+	@Query(value = "SELECT m "
+		+ "FROM Movie m "
+		+ "WHERE title = :title "
+		+ "AND deleted_at IS NULL")
+	Optional<Movie> findValidMovieWithTitle(String title);
+
     @Query(value = "SELECT * "
         + "FROM movie "
         + "WHERE deleted_at IS NULL", nativeQuery = true)

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

@@ -2,8 +2,10 @@ package com.ticketing.server.movie.domain.repository;
 
 import com.ticketing.server.movie.domain.Movie;
 import com.ticketing.server.movie.domain.MovieTime;
+import com.ticketing.server.movie.domain.Theater;
 import java.time.LocalDateTime;
 import java.util.List;
+import java.util.Optional;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.stereotype.Repository;
@@ -11,11 +13,13 @@ 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);
+	Optional<MovieTime> findByMovieAndTheaterAndRoundAndDeletedAtNull(Movie movie, Theater theater, Integer round);
+
+	@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/service/MovieServiceImpl.java

@@ -3,12 +3,15 @@ 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.DeletedMovieDTO;
 import com.ticketing.server.movie.service.dto.MovieDTO;
-import com.ticketing.server.movie.service.dto.MovieRegisterDTO;
+import com.ticketing.server.movie.service.dto.MovieListDTO;
+import com.ticketing.server.movie.service.dto.RegisteredMovieDTO;
 import com.ticketing.server.movie.service.interfaces.MovieService;
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;
+import javax.transaction.Transactional;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
@@ -21,24 +24,39 @@ public class MovieServiceImpl implements MovieService {
 	private final MovieRepository movieRepository;
 
 	@Override
-	public MovieDTO registerMovie(MovieRegisterDTO movieRegisterDto) {
-		Optional<Movie> movie = movieRepository.findByTitle(movieRegisterDto.getTitle());
+	public RegisteredMovieDTO registerMovie(String title, Long runningTime) {
+		Optional<Movie> movie = movieRepository.findValidMovieWithTitle(title);
 
 		if(movie.isEmpty()) {
-			return MovieDTO.from(movieRepository.save(movieRegisterDto.toMovie()));
+			Movie newMovie = movieRepository.save(
+				new Movie(title, runningTime)
+			);
+
+			return new RegisteredMovieDTO(newMovie);
 		}
 
 		throw ErrorCode.throwDuplicateMovie();
 	}
 
 	@Override
-	public List<MovieDTO> getMovies() {
+	public MovieListDTO getMovies() {
 		List<Movie> movies = movieRepository.findValidMovies();
 
-		return movies.stream()
-			.map(MovieDTO::from)
+		List<MovieDTO> movieDtos = movies.stream()
+			.map(movie -> movie.toMovieDTO())
 			.collect(Collectors.toList());
 
+		return new MovieListDTO(movieDtos);
 	}
 
+	@Override
+	@Transactional
+	public DeletedMovieDTO deleteMovie(Long id) {
+		Movie movie = movieRepository.findByIdAndDeletedAtNull(id)
+			.orElseThrow(ErrorCode::throwMovieNotFound);
+
+		Movie deletedMovie = movie.delete();
+
+		return new DeletedMovieDTO(deletedMovie);
+	}
 }

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

@@ -3,14 +3,22 @@ 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.Theater;
 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.service.dto.MovieTimeDTO;
+import com.ticketing.server.movie.service.dto.MovieTimeListDTO;
+import com.ticketing.server.movie.service.dto.MovieTimeRegisterDTO;
+import com.ticketing.server.movie.service.dto.RegisteredMovieDTO;
+import com.ticketing.server.movie.service.dto.RegisteredMovieTimeDTO;
 import com.ticketing.server.movie.service.interfaces.MovieTimeService;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Collectors;
+import javax.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
@@ -22,22 +30,60 @@ public class MovieTimeServiceImpl implements MovieTimeService {
 
 	private final MovieRepository movieRepository;
 
+	private final TheaterRepository theaterRepository;
+
 	private final MovieTimeRepository movieTimeRepository;
 
 	@Override
-	public List<MovieTimeDTO> getMovieTimes(String title, LocalDate runningDate) {
-		Movie movie = movieRepository.findByTitle(title)
-			.orElseThrow(ErrorCode::throwMovieNotFound);
+	public RegisteredMovieTimeDTO registerMovieTime(@Valid MovieTimeRegisterDTO movieTimeRegisterDto) {
+		Movie movie = findMovieById(movieTimeRegisterDto.getMovieId());
+		Theater theater = findTheaterByNumber(movieTimeRegisterDto.getTheaterNumber());
+		int round = movieTimeRegisterDto.getRound();
+
+		Optional<MovieTime> movieTime =
+			movieTimeRepository.findByMovieAndTheaterAndRoundAndDeletedAtNull(movie, theater, round);
+
+		if(movieTime.isEmpty()) {
+			MovieTime newMovieTime = movieTimeRepository.save(
+				new MovieTime(movie, theater, round, movieTimeRegisterDto.getStartAt())
+			);
+
+			return new RegisteredMovieTimeDTO(newMovieTime);
+		}
+
+		throw ErrorCode.throwDuplicateMovieTime();
+	}
+
+	@Override
+	public MovieTimeListDTO getMovieTimes(Long movieId, LocalDate runningDate) {
+		Movie movie = findMovieById(movieId);
 
 		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)
+		List<MovieTimeDTO> movieTimeDtos = movieTimes.stream()
+			.map(movieTime -> movieTime.toMovieTimeDTO())
 			.collect(Collectors.toList());
 
+		return new MovieTimeListDTO(movieTimeDtos);
+	}
+
+	@Override
+	public Movie findMovieById(Long movieId) {
+		Movie movie = movieRepository.findByIdAndDeletedAtNull(movieId)
+			.orElseThrow(ErrorCode::throwMovieNotFound);
+
+		return movie;
+	}
+
+	@Override
+	public Theater findTheaterByNumber(Integer theaterNumber) {
+		Theater theater = theaterRepository.findByTheaterNumber(theaterNumber)
+			.orElseThrow(ErrorCode::throwTheaterNotFound);
+
+		return theater;
 	}
 
 }

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

@@ -4,7 +4,7 @@ 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.application.response.TicketDetailDTO;
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
 import java.util.List;
 import java.util.stream.Collectors;
 import javax.validation.constraints.NotNull;

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

@@ -0,0 +1,32 @@
+package com.ticketing.server.movie.service.dto;
+
+import com.ticketing.server.movie.application.response.MovieDeleteResponse;
+import com.ticketing.server.movie.domain.Movie;
+import java.time.LocalDateTime;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class DeletedMovieDTO {
+
+	private final Long id;
+
+	private final String title;
+
+	private final LocalDateTime deletedAt;
+
+	public DeletedMovieDTO(Movie movie) {
+		this(
+			movie.getId(),
+			movie.getTitle(),
+			movie.getDeletedAt()
+		);
+	}
+
+	public MovieDeleteResponse toResponse() {
+		return new MovieDeleteResponse(id, title, deletedAt);
+	}
+
+}

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

@@ -1,18 +1,14 @@
 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)
+@AllArgsConstructor
 public class MovieDTO {
 
+	private Long movieId;
+
     private String title;
 
-    public static MovieDTO from(Movie movie) {
-        return new MovieDTO(movie.getTitle());
-    }
-
 }

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

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

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

@@ -21,4 +21,5 @@ public class MovieRegisterDTO {
 	public Movie toMovie() {
 		return new Movie(this.title, this.runningTime);
 	}
+
 }

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

@@ -1,13 +1,11 @@
 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)
+@AllArgsConstructor
 public class MovieTimeDTO {
 
     private Long movieTimeId;
@@ -20,9 +18,4 @@ public class MovieTimeDTO {
 
     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/MovieTimeListDTO.java

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

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

@@ -0,0 +1,25 @@
+package com.ticketing.server.movie.service.dto;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import java.time.LocalDateTime;
+import javax.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class MovieTimeRegisterDTO {
+
+	@NotNull(message = "{validation.not.null.movieId}")
+	private Long movieId;
+
+	@NotNull(message = "{validation.not.null.theaterNumber}")
+	private Integer theaterNumber;
+
+	@NotNull(message = "{validation.not.null.round}")
+	private Integer round;
+
+	@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Seoul")
+	private LocalDateTime startAt;
+
+}

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

@@ -0,0 +1,28 @@
+package com.ticketing.server.movie.service.dto;
+
+import com.ticketing.server.movie.application.response.MovieInfoResponse;
+import com.ticketing.server.movie.domain.Movie;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class RegisteredMovieDTO {
+
+	private final Long id;
+
+	private final String title;
+
+	public RegisteredMovieDTO(Movie movie) {
+		this(
+			movie.getId(),
+			movie.getTitle()
+		);
+	}
+
+	public MovieInfoResponse toResponse() {
+		return new MovieInfoResponse(id, title);
+	}
+
+}

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

@@ -0,0 +1,38 @@
+package com.ticketing.server.movie.service.dto;
+
+import com.ticketing.server.movie.application.response.MovieTimeInfoResponse;
+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 RegisteredMovieTimeDTO {
+
+	private final Long movieTimeId;
+
+	private final Integer theaterNumber;
+
+	private final Integer round;
+
+	private final LocalDateTime startAt;
+
+	private final LocalDateTime endAt;
+
+	public RegisteredMovieTimeDTO(MovieTime movieTime) {
+		this(
+			movieTime.getId(),
+			movieTime.getTheater().getTheaterNumber(),
+			movieTime.getRound(),
+			movieTime.getStartAt(),
+			movieTime.getEndAt()
+		);
+	}
+
+	public MovieTimeInfoResponse toResponse() {
+		return new MovieTimeInfoResponse(movieTimeId, theaterNumber, round, startAt, endAt);
+	}
+
+}

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

@@ -1,7 +1,7 @@
 package com.ticketing.server.movie.service.dto;
 
 import com.ticketing.server.movie.application.response.TicketDetailsResponse;
-import com.ticketing.server.payment.application.response.TicketDetailDTO;
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
 import java.util.List;
 import lombok.AllArgsConstructor;
 import lombok.Getter;

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

@@ -1,13 +1,14 @@
 package com.ticketing.server.movie.service.interfaces;
 
-import com.ticketing.server.movie.service.dto.MovieDTO;
-import com.ticketing.server.movie.service.dto.MovieRegisterDTO;
-import java.util.List;
+import com.ticketing.server.movie.service.dto.DeletedMovieDTO;
+import com.ticketing.server.movie.service.dto.MovieListDTO;
+import com.ticketing.server.movie.service.dto.RegisteredMovieDTO;
 
 public interface MovieService {
 
-	MovieDTO registerMovie(MovieRegisterDTO movieRegisterDto);
+	RegisteredMovieDTO registerMovie(String title, Long runningTime);
 
-    List<MovieDTO> getMovies();
+	MovieListDTO getMovies();
 
+	DeletedMovieDTO deleteMovie(Long id);
 }

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

@@ -1,11 +1,21 @@
 package com.ticketing.server.movie.service.interfaces;
 
-import com.ticketing.server.movie.service.dto.MovieTimeDTO;
+import com.ticketing.server.movie.domain.Movie;
+import com.ticketing.server.movie.domain.Theater;
+import com.ticketing.server.movie.service.dto.MovieTimeListDTO;
+import com.ticketing.server.movie.service.dto.MovieTimeRegisterDTO;
+import com.ticketing.server.movie.service.dto.RegisteredMovieTimeDTO;
 import java.time.LocalDate;
-import java.util.List;
+import javax.validation.Valid;
 
 public interface MovieTimeService {
 
-    List<MovieTimeDTO> getMovieTimes(String title, LocalDate runningDate);
+	RegisteredMovieTimeDTO registerMovieTime(@Valid MovieTimeRegisterDTO movieTimeRegisterDto);
+
+	MovieTimeListDTO getMovieTimes(Long movieId, LocalDate runningDate);
+
+	Movie findMovieById(Long movieId);
+
+	Theater findTheaterByNumber(Integer theaterNumber);
 
 }

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

@@ -1,10 +1,11 @@
 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.payment.application.response.SimplePaymentsResponse;
 import com.ticketing.server.user.domain.UserGrade;
 import javax.validation.constraints.NotNull;
 import lombok.RequiredArgsConstructor;
@@ -29,14 +30,18 @@ public class PaymentController {
 	@Secured(UserGrade.ROLES.USER)
 	public ResponseEntity<SimplePaymentsResponse> simplePayments(@NotNull Long userAlternateId) {
 		SimplePaymentsDTO simplePayments = paymentService.findSimplePayments(userAlternateId);
-		return ResponseEntity.status(HttpStatus.OK).body(simplePayments.toResponse());
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(simplePayments.toResponse());
 	}
 
 	@GetMapping("/detail")
 	@Secured(UserGrade.ROLES.USER)
 	public ResponseEntity<PaymentDetailResponse> detail(@NotNull Long paymentId) {
-		PaymentDetailResponse paymentDetail = paymentApisService.findPaymentDetail(paymentId);
-		return ResponseEntity.status(HttpStatus.OK).body(paymentDetail);
+		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

@@ -1,38 +1,20 @@
 package com.ticketing.server.payment.application.response;
 
-import com.ticketing.server.movie.application.response.TicketDetailsResponse;
-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)
+@AllArgsConstructor
 public class PaymentDetailResponse {
 
 	private Long paymentId;
-
 	private String movieTitle;
-
 	private String paymentNumber;
-
 	private Integer totalPrice;
-
 	private LocalDateTime createdAt;
-
-	List<TicketDetailDTO> tickets;
-
-	public PaymentDetailResponse(Payment payment, TicketDetailsResponse ticketDetails) {
-		this(
-			payment.getId(),
-			payment.getMovieTitle(),
-			payment.getPaymentNumber(),
-			payment.getTotalPrice(),
-			payment.getCreatedAt(),
-			ticketDetails.getTicketDetails()
-		);
-	}
+	private List<TicketDetailDTO> tickets;
 
 }

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

@@ -10,7 +10,6 @@ import lombok.Getter;
 public class SimplePaymentsResponse {
 
 	private final Long userAlternateId;
-
 	private final List<SimplePaymentDTO> payments;
 
 }

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

@@ -1,36 +0,0 @@
-package com.ticketing.server.payment.application.response;
-
-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 Integer price;
-
-	private Integer theaterNumber;
-
-	private Integer column;
-
-	private Integer row;
-
-	private LocalDateTime startAt;
-
-	private 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/PaymentApisServiceImpl.java

@@ -5,9 +5,9 @@ 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.application.response.PaymentDetailResponse;
 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;
@@ -28,7 +28,7 @@ public class PaymentApisServiceImpl implements PaymentApisService {
 	private final UserClient userClient;
 
 	@Override
-	public PaymentDetailResponse findPaymentDetail(@NotNull Long paymentId) {
+	public PaymentDetailDTO findPaymentDetail(@NotNull Long paymentId) {
 		Payment payment = paymentRepository.findById(paymentId)
 			.orElseThrow(ErrorCode::throwPaymentIdNotFound);
 
@@ -38,7 +38,7 @@ public class PaymentApisServiceImpl implements PaymentApisService {
 		}
 
 		TicketDetailsResponse tickets = movieClient.getTicketsByPaymentId(payment.getId());
-		return new PaymentDetailResponse(payment, tickets);
+		return new PaymentDetailDTO(payment, tickets);
 	}
 
 }

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

@@ -10,12 +10,12 @@ import lombok.Getter;
 @AllArgsConstructor
 public class CreatePaymentDTO {
 
-	private Long userAlternateId;
-	private String movieTitle;
-	private PaymentType type;
-	private PaymentStatus status;
-	private String paymentNumber;
-	private Integer totalPrice;
+	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

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

@@ -9,10 +9,10 @@ import lombok.Getter;
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public class SimplePaymentDTO {
 
-	private Long paymentId;
-	private String movieTitle;
-	private String paymentNumber;
-	private Integer totalPrice;
+	private final Long paymentId;
+	private final String movieTitle;
+	private final String paymentNumber;
+	private final Integer totalPrice;
 
 	public SimplePaymentDTO(Payment payment) {
 		this(

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

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

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/UserController.java

@@ -13,7 +13,11 @@ 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.ChangeGradeDTO;
-import com.ticketing.server.user.domain.User;
+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.DeletedUserDTO;
+import com.ticketing.server.user.service.dto.PaymentsDTO;
 import com.ticketing.server.user.service.dto.UserDetailDTO;
 import com.ticketing.server.user.service.interfaces.UserApisService;
 import com.ticketing.server.user.service.interfaces.UserService;
@@ -40,28 +44,34 @@ import org.springframework.web.bind.annotation.RestController;
 @Slf4j
 public class UserController {
 
-	private final UserApisService userApisService;
 	private final UserService userService;
+	private final UserApisService userApisService;
 	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(USER)
 	public ResponseEntity<UserDetailResponse> details(@AuthenticationPrincipal UserDetails userRequest) {
 		UserDetailDTO userDetail = userService.findDetailByEmail(userRequest.getUsername());
-		return ResponseEntity.status(HttpStatus.OK).body(userDetail.toResponse());
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(userDetail.toResponse());
 	}
 
 	@DeleteMapping
 	@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")
@@ -69,22 +79,29 @@ public class UserController {
 	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());
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(changeGradeDto.toResponse());
 	}
 
 	@GetMapping("/payments")
 	@Secured(USER)
 	public ResponseEntity<PaymentsResponse> getPayments(@AuthenticationPrincipal UserDetails userRequest) {
-		PaymentsResponse paymentDetails = userApisService.findPaymentsByEmail(userRequest.getUsername());
-		return ResponseEntity.status(HttpStatus.OK).body(paymentDetails);
+		PaymentsDTO paymentsDto = userApisService.findPaymentsByEmail(userRequest.getUsername());
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(paymentsDto.toResponse());
 	}
 
 }

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

@@ -1,6 +1,5 @@
 package com.ticketing.server.user.application.response;
 
-import com.ticketing.server.payment.application.response.SimplePaymentsResponse;
 import com.ticketing.server.payment.service.dto.SimplePaymentDTO;
 import java.util.List;
 import lombok.AllArgsConstructor;
@@ -10,11 +9,7 @@ import lombok.Getter;
 @AllArgsConstructor
 public class PaymentsResponse {
 
-	private String email;
-	private List<SimplePaymentDTO> payments;
+	private final String email;
+	private final List<SimplePaymentDTO> payments;
 
-	public PaymentsResponse(String email, SimplePaymentsResponse simplePayments) {
-		this(email, simplePayments.getPayments());
-	}
-	
 }

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

@@ -7,7 +7,7 @@ import lombok.AllArgsConstructor;
 import lombok.Getter;
 
 @Getter
-@AllArgsConstructor(access = AccessLevel.PRIVATE)
+@AllArgsConstructor
 public class UserDetailResponse {
 
 	private final String name;
@@ -15,13 +15,4 @@ public class UserDetailResponse {
 	private final UserGrade grade;
 	private final String phone;
 
-	public UserDetailResponse(UserDetailDTO userDetailDto) {
-		this(
-			userDetailDto.getName(),
-			userDetailDto.getEmail(),
-			userDetailDto.getGrade(),
-			userDetailDto.getPhone()
-		);
-	}
-
 }

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

@@ -5,8 +5,8 @@ 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;
@@ -28,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)
@@ -49,7 +49,7 @@ public class AuthenticationServiceImpl implements AuthenticationService {
 
 	@Override
 	@Transactional
-	public TokenDto reissueTokenDto(String bearerRefreshToken) {
+	public TokenDTO reissueTokenDto(String bearerRefreshToken) {
 		String refreshToken = resolveToken(bearerRefreshToken);
 
 		// 토큰 검증
@@ -67,7 +67,7 @@ public class AuthenticationServiceImpl implements AuthenticationService {
 		}
 
 		// 토큰 발급
-		TokenDto tokenDto = jwtProvider.generateTokenDto(authentication);
+		TokenDTO tokenDto = jwtProvider.generateTokenDto(authentication);
 
 		// 토큰 최신화
 		findTokenEntity.changeToken(tokenDto.getRefreshToken());
@@ -78,12 +78,14 @@ 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) {

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

@@ -2,8 +2,8 @@ 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.application.response.PaymentsResponse;
 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;
@@ -24,11 +24,11 @@ public class UserApisServiceImpl implements UserApisService {
 	private final UserService userService;
 
 	@Override
-	public PaymentsResponse findPaymentsByEmail(@NotNull String email) {
+	public PaymentsDTO findPaymentsByEmail(@NotNull String email) {
 		User user = userService.findNotDeletedUserByEmail(email);
 		SimplePaymentsResponse simplePayments = paymentClient.getPayments(user.getAlternateId());
 
-		return new PaymentsResponse(user.getEmail(), simplePayments);
+		return new PaymentsDTO(user, simplePayments);
 	}
 
 }

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

@@ -7,7 +7,10 @@ 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;
@@ -32,10 +35,11 @@ public class UserServiceImpl implements UserService {
 
 	@Override
 	@Transactional
-	public User register(@Valid SignUpDTO signUpDto) {
-		Optional<User> user = userRepository.findByEmail(signUpDto.getEmail());
-		if (user.isEmpty()) {
-			return userRepository.save(signUpDto.toUser(sequenceGenerator.generateId()));
+	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 ErrorCode.throwDuplicateEmail();
@@ -43,16 +47,20 @@ public class UserServiceImpl implements UserService {
 
 	@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

server/src/main/java/com/ticketing/server/user/service/dto/ChangePasswordDTO.java

@@ -2,28 +2,23 @@ package com.ticketing.server.user.service.dto;
 
 import javax.validation.constraints.Email;
 import javax.validation.constraints.NotEmpty;
+import lombok.AllArgsConstructor;
 import org.springframework.security.crypto.password.PasswordEncoder;
 
+@AllArgsConstructor
 public class ChangePasswordDTO implements PasswordMatches {
 
 	@NotEmpty(message = "{validation.not.empty.email}")
 	@Email(message = "{validation.email}")
-	private String email;
+	private final String email;
 
 	@NotEmpty(message = "{validation.not.empty.oldpassword}")
-	private String oldPassword;
+	private final String oldPassword;
 
 	@NotEmpty(message = "{validation.not.empty.newpassword}")
-	private String newPassword;
+	private final String newPassword;
 
-	private PasswordEncoder passwordEncoder;
-
-	public ChangePasswordDTO(String email, String oldPassword, String newPassword, PasswordEncoder passwordEncoder) {
-		this.email = email;
-		this.oldPassword = oldPassword;
-		this.newPassword = newPassword;
-		this.passwordEncoder = passwordEncoder;
-	}
+	private final PasswordEncoder passwordEncoder;
 
 	public String getEmail() {
 		return email;

server/src/main/java/com/ticketing/server/user/service/dto/ChangedPasswordUserDTO.java

@@ -0,0 +1,24 @@
+package com.ticketing.server.user.service.dto;
+
+import com.ticketing.server.user.application.response.UserChangePasswordResponse;
+import com.ticketing.server.user.domain.User;
+import java.time.LocalDateTime;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class ChangedPasswordUserDTO {
+
+	private final String name;
+	private final String email;
+	private final LocalDateTime updatedAt;
+
+	public ChangedPasswordUserDTO(User user) {
+		this(user.getName(), user.getEmail(), user.getUpdatedAt());
+	}
+
+	public UserChangePasswordResponse toResponse() {
+		return new UserChangePasswordResponse(name, email, updatedAt);
+	}
+
+}

server/src/main/java/com/ticketing/server/user/service/dto/CreatedUserDTO.java

@@ -0,0 +1,25 @@
+package com.ticketing.server.user.service.dto;
+
+import com.ticketing.server.user.application.response.SignUpResponse;
+import com.ticketing.server.user.domain.User;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class CreatedUserDTO {
+
+	private final String name;
+	private final String email;
+
+	public CreatedUserDTO(User user) {
+		this(
+			user.getName(),
+			user.getEmail()
+		);
+	}
+
+	public SignUpResponse toResponse() {
+		return new SignUpResponse(name, email);
+	}
+
+}

server/src/main/java/com/ticketing/server/user/service/dto/DeleteRefreshTokenDTO.java

@@ -0,0 +1,26 @@
+package com.ticketing.server.user.service.dto;
+
+import com.ticketing.server.global.redis.RefreshToken;
+import com.ticketing.server.user.application.response.LogoutResponse;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class DeleteRefreshTokenDTO {
+
+	private final Long refreshTokenId;
+	private final String email;
+	private final String refreshToken;
+
+	public DeleteRefreshTokenDTO(String email) {
+		this(null, email, null);
+	}
+
+	public DeleteRefreshTokenDTO(RefreshToken refreshToken) {
+		this(refreshToken.getId(), refreshToken.getEmail(), refreshToken.getToken());
+	}
+
+	public LogoutResponse toResponse() {
+		return new LogoutResponse(refreshTokenId, email, refreshToken);
+	}
+}

server/src/main/java/com/ticketing/server/user/service/dto/DeleteUserDTO.java

@@ -2,24 +2,20 @@ package com.ticketing.server.user.service.dto;
 
 import javax.validation.constraints.Email;
 import javax.validation.constraints.NotEmpty;
+import lombok.AllArgsConstructor;
 import org.springframework.security.crypto.password.PasswordEncoder;
 
+@AllArgsConstructor
 public class DeleteUserDTO implements PasswordMatches {
 
 	@NotEmpty(message = "{validation.not.empty.email}")
 	@Email(message = "{validation.email}")
-	private String email;
+	private final String email;
 
 	@NotEmpty(message = "{validation.not.empty.password}")
-	private String inputPassword;
+	private final String inputPassword;
 
-	private PasswordEncoder passwordEncoder;
-
-	public DeleteUserDTO(String email, String inputPassword, PasswordEncoder passwordEncoder) {
-		this.email = email;
-		this.inputPassword = inputPassword;
-		this.passwordEncoder = passwordEncoder;
-	}
+	private final PasswordEncoder passwordEncoder;
 
 	@Override
 	public boolean passwordMatches(String password) {

server/src/main/java/com/ticketing/server/user/service/dto/DeletedUserDTO.java

@@ -0,0 +1,26 @@
+package com.ticketing.server.user.service.dto;
+
+import com.ticketing.server.user.application.response.UserDeleteResponse;
+import com.ticketing.server.user.domain.User;
+import java.time.LocalDateTime;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class DeletedUserDTO {
+
+	private final String name;
+	private final String email;
+	private final LocalDateTime deletedAt;
+
+	public DeletedUserDTO(User user) {
+		this(user.getName(), user.getEmail(), user.getDeletedAt());
+	}
+
+	public UserDeleteResponse toResponse() {
+		return new UserDeleteResponse(name, email, deletedAt);
+	}
+
+}

server/src/main/java/com/ticketing/server/user/service/dto/PaymentsDTO.java

@@ -0,0 +1,27 @@
+package com.ticketing.server.user.service.dto;
+
+import com.ticketing.server.payment.application.response.SimplePaymentsResponse;
+import com.ticketing.server.payment.service.dto.SimplePaymentDTO;
+import com.ticketing.server.user.application.response.PaymentsResponse;
+import com.ticketing.server.user.domain.User;
+import java.util.List;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class PaymentsDTO {
+
+	private final String email;
+	private final List<SimplePaymentDTO> payments;
+
+	public PaymentsDTO(User user, SimplePaymentsResponse simplePayments) {
+		this(user.getEmail(), simplePayments.getPayments());
+	}
+
+	public PaymentsResponse toResponse() {
+		return new PaymentsResponse(email, payments);
+	}
+
+}

server/src/main/java/com/ticketing/server/user/service/dto/SignUpDTO.java

@@ -13,18 +13,18 @@ import lombok.Getter;
 public class SignUpDTO {
 
 	@NotEmpty(message = "{validation.not.empty.name}")
-	private String name;
+	private final String name;
 
 	@NotEmpty(message = "{validation.not.empty.email}")
 	@Email(message = "{validation.email}")
-	private String email;
+	private final String email;
 
 	@NotEmpty(message = "{validation.not.empty.password}")
-	private String password;
+	private final String password;
 
 	@NotEmpty(message = "{validation.not.empty.phone}")
 	@Phone
-	private String phone;
+	private final String phone;
 
 	public User toUser(long alternateId) {
 		return new User(alternateId, this.name, this.email, password, UserGrade.USER, this.phone);

server/src/main/java/com/ticketing/server/user/service/dto/TokenDTO.java

@@ -0,0 +1,20 @@
+package com.ticketing.server.user.service.dto;
+
+import com.ticketing.server.user.application.response.TokenResponse;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class TokenDTO {
+
+	private final String accessToken;
+	private final String refreshToken;
+	private final String tokenType;
+	private final long expiresIn;
+
+	public TokenResponse toResponse() {
+		return new TokenResponse(accessToken, refreshToken, tokenType, expiresIn);
+	}
+
+}

server/src/main/java/com/ticketing/server/user/service/dto/UserDetailDTO.java

@@ -11,11 +11,11 @@ import lombok.Getter;
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public class UserDetailDTO {
 
-	private Long alternateId;
-	private String name;
-	private String email;
-	private UserGrade grade;
-	private String phone;
+	private final Long alternateId;
+	private final String name;
+	private final String email;
+	private final UserGrade grade;
+	private final String phone;
 
 	public UserDetailDTO(User user) {
 		this(
@@ -28,6 +28,7 @@ public class UserDetailDTO {
 	}
 
 	public UserDetailResponse toResponse() {
-		return new UserDetailResponse(this);
+		return new UserDetailResponse(name, email, grade, phone);
 	}
+
 }

server/src/main/java/com/ticketing/server/user/service/interfaces/AuthenticationService.java

@@ -1,15 +1,15 @@
 package com.ticketing.server.user.service.interfaces;
 
-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 org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
 
 public interface AuthenticationService {
 
-	TokenDto generateTokenDto(UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken);
+	TokenDTO generateTokenDto(UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken);
 
-	TokenDto reissueTokenDto(String bearerRefreshToken);
+	TokenDTO reissueTokenDto(String bearerRefreshToken);
 
-	LogoutResponse deleteRefreshToken(String email);
+	DeleteRefreshTokenDTO deleteRefreshToken(String email);
 
 }

server/src/main/java/com/ticketing/server/user/service/interfaces/UserApisService.java

@@ -1,10 +1,10 @@
 package com.ticketing.server.user.service.interfaces;
 
-import com.ticketing.server.user.application.response.PaymentsResponse;
+import com.ticketing.server.user.service.dto.PaymentsDTO;
 import javax.validation.constraints.NotNull;
 
 public interface UserApisService {
 
-	PaymentsResponse findPaymentsByEmail(@NotNull String email);
+	PaymentsDTO findPaymentsByEmail(@NotNull String email);
 
 }

server/src/main/java/com/ticketing/server/user/service/interfaces/UserService.java

@@ -3,23 +3,24 @@ package com.ticketing.server.user.service.interfaces;
 import com.ticketing.server.user.domain.ChangeGradeDTO;
 import com.ticketing.server.user.domain.User;
 import com.ticketing.server.user.domain.UserGrade;
+import com.ticketing.server.user.service.dto.ChangedPasswordUserDTO;
+import com.ticketing.server.user.service.dto.DeletedUserDTO;
 import com.ticketing.server.user.service.dto.ChangePasswordDTO;
+import com.ticketing.server.user.service.dto.CreatedUserDTO;
 import com.ticketing.server.user.service.dto.DeleteUserDTO;
 import com.ticketing.server.user.service.dto.SignUpDTO;
 import com.ticketing.server.user.service.dto.UserDetailDTO;
 import javax.validation.Valid;
 import javax.validation.constraints.NotNull;
-import org.springframework.transaction.annotation.Transactional;
 
 public interface UserService {
 
-	User register(@Valid SignUpDTO signUpDto);
+	CreatedUserDTO register(@Valid SignUpDTO signUpDto);
 
-	User delete(@Valid DeleteUserDTO deleteUserDto);
+	DeletedUserDTO delete(@Valid DeleteUserDTO deleteUserDto);
 
-	User changePassword(@Valid ChangePasswordDTO changePasswordDto);
+	ChangedPasswordUserDTO changePassword(@Valid ChangePasswordDTO changePasswordDto);
 
-	@Transactional
 	ChangeGradeDTO changeGrade(@NotNull String email, @NotNull UserGrade grade);
 
 	UserDetailDTO findDetailByEmail(@NotNull String email);

server/src/test/java/com/ticketing/server/global/security/jwt/TokenProviderTest.java

@@ -3,7 +3,7 @@ package com.ticketing.server.global.security.jwt;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import com.ticketing.server.global.factory.YamlPropertySourceFactory;
-import com.ticketing.server.user.application.response.TokenDto;
+import com.ticketing.server.user.service.dto.TokenDTO;
 import com.ticketing.server.user.domain.UserGrade;
 import java.util.Collections;
 import org.junit.jupiter.api.BeforeEach;
@@ -43,10 +43,10 @@ class TokenProviderTest {
 			new UsernamePasswordAuthenticationToken("ticketing@gmail.com", "123456", Collections.singleton(grantedAuthority));
 
 		// when
-		TokenDto tokenDto = jwtProvider.generateTokenDto(authenticationToken);
+		TokenDTO tokenDto = jwtProvider.generateTokenDto(authenticationToken);
 
 		// then
-		assertThat(tokenDto).isInstanceOf(TokenDto.class);
+		assertThat(tokenDto).isInstanceOf(TokenDTO.class);
 	}
 
 	@Test
@@ -58,7 +58,7 @@ class TokenProviderTest {
 			new UsernamePasswordAuthenticationToken("ticketing@gmail.com", "123456", Collections.singleton(grantedAuthority));
 
 		// when
-		TokenDto tokenDto = jwtProvider.generateTokenDto(authenticationToken);
+		TokenDTO tokenDto = jwtProvider.generateTokenDto(authenticationToken);
 		Authentication authentication = jwtProvider.getAuthentication(tokenDto.getAccessToken());
 
 		// then

server/src/test/java/com/ticketing/server/movie/service/MovieServiceImplTest.java

@@ -6,6 +6,7 @@ import static org.mockito.Mockito.when;
 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.MovieListDTO;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -38,10 +39,10 @@ public class MovieServiceImplTest {
             .thenReturn(Collections.emptyList());
 
         // when
-        List<MovieDTO> movieDTOList = movieService.getMovies();
+        MovieListDTO movieListDto = movieService.getMovies();
 
         // then
-        assertTrue(movieDTOList.isEmpty());
+        assertTrue(movieListDto.getMovieDtos().isEmpty());
     }
 
     @Test
@@ -49,18 +50,16 @@ public class MovieServiceImplTest {
     void shouldAbleToGetMovies() {
         // given
         movie = new Movie("범죄도시2", 106L);
-        movieDto = movieDto.from(movie);
         movies.add(movie);
-        movieDTOS.add(movieDto);
 
         when(movieRepository.findValidMovies())
             .thenReturn(movies);
 
         // when
-        List<MovieDTO> movieDTOList = movieService.getMovies();
+	    MovieListDTO movieListDto = movieService.getMovies();
 
         // then
-        assertTrue(!movieDTOList.isEmpty());
+        assertTrue(!movieListDto.getMovieDtos().isEmpty());
     }
 
 }

server/src/test/java/com/ticketing/server/movie/service/MovieTimeServiceImplTest.java

@@ -9,7 +9,7 @@ import com.ticketing.server.movie.domain.MovieTime;
 import com.ticketing.server.movie.domain.Theater;
 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.dto.MovieTimeListDTO;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
@@ -39,26 +39,26 @@ public class MovieTimeServiceImplTest {
     MovieTimeServiceImpl movieTimeService;
 
     @Test
-    @DisplayName("MovieTime Service Test - get empty list when there is no valid movie times")
+    @DisplayName("MovieTime Service Test - get empty list when there are no valid movie times")
     void shouldGetEmptyList() {
         // given
         Movie movie = new Movie(title, 106L);
 
-        when(movieRepository.findByTitle(title))
+        when(movieRepository.findByIdAndDeletedAtNull(any()))
             .thenReturn(Optional.of(movie));
 
         when(movieTimeRepository.findValidMovieTimes(any(), any(), any()))
             .thenReturn(Collections.emptyList());
 
         // when
-        List<MovieTimeDTO> movieTimeDTOList = movieTimeService.getMovieTimes(title, LocalDate.now());
+        MovieTimeListDTO movieTimeListDto = movieTimeService.getMovieTimes(any(), LocalDate.now());
 
         // then
-        assertTrue(movieTimeDTOList.isEmpty());
+        assertTrue(movieTimeListDto.getMovieTimeDtos().isEmpty());
     }
 
     @Test
-    @DisplayName("MovieTime Service Test - get list when there is valid movie times")
+    @DisplayName("MovieTime Service Test - get list when there are valid movie times")
     void shouldGetMovieTimeList() {
         // given
         Movie movie = new Movie(title, 106L);
@@ -69,17 +69,17 @@ public class MovieTimeServiceImplTest {
 
         movieTimes.add(movieTime);
 
-        when(movieRepository.findByTitle(title))
+        when(movieRepository.findByIdAndDeletedAtNull(any()))
             .thenReturn(Optional.of(movie));
 
         when(movieTimeRepository.findValidMovieTimes(any(), any(), any()))
             .thenReturn(movieTimes);
 
         // when
-        List<MovieTimeDTO> movieTimeDTOList = movieTimeService.getMovieTimes(title, LocalDate.of(2022, 07, 01));
+	    MovieTimeListDTO movieTimeListDto = movieTimeService.getMovieTimes(any(), LocalDate.of(2022, 07, 01));
 
         // then
-        assertTrue(!movieTimeDTOList.isEmpty());
+        assertTrue(!movieTimeListDto.getMovieTimeDtos().isEmpty());
     }
 
 }

server/src/test/java/com/ticketing/server/movie/service/TicketServiceImplTest.java

@@ -11,7 +11,7 @@ import com.ticketing.server.global.exception.TicketingException;
 import com.ticketing.server.movie.domain.Ticket;
 import com.ticketing.server.movie.domain.repository.TicketRepository;
 import com.ticketing.server.movie.service.dto.TicketDetailsDTO;
-import com.ticketing.server.payment.application.response.TicketDetailDTO;
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
 import java.util.Collections;
 import java.util.List;
 import org.junit.jupiter.api.DisplayName;

server/src/test/java/com/ticketing/server/payment/service/PaymentApisServiceImplTest.java

@@ -16,7 +16,8 @@ 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.application.response.PaymentDetailResponse;
-import com.ticketing.server.payment.application.response.TicketDetailDTO;
+import com.ticketing.server.payment.service.dto.PaymentDetailDTO;
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
 import com.ticketing.server.payment.domain.repository.PaymentRepository;
 import com.ticketing.server.user.domain.User;
 import com.ticketing.server.user.service.dto.UserDetailDTO;
@@ -104,7 +105,7 @@ class PaymentApisServiceImplTest {
 		when(movieClient.getTicketsByPaymentId(1L)).thenReturn(response);
 
 		// when
-		PaymentDetailResponse paymentDetail = paymentApisService.findPaymentDetail(1L);
+		PaymentDetailDTO paymentDetail = paymentApisService.findPaymentDetail(1L);
 
 		// then
 		assertAll(

server/src/test/java/com/ticketing/server/user/service/AuthenticationServiceImplTest.java

@@ -10,7 +10,7 @@ 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.TokenDto;
+import com.ticketing.server.user.service.dto.TokenDTO;
 import com.ticketing.server.user.domain.UserGrade;
 import java.util.Collections;
 import java.util.Optional;
@@ -70,7 +70,7 @@ class AuthenticationServiceImplTest {
 		when(jwtProperties.hasTokenStartsWith(refreshToken)).thenReturn(true);
 
 		// when
-		TokenDto tokenDto = authenticationService.reissueTokenDto(refreshToken);
+		TokenDTO tokenDto = authenticationService.reissueTokenDto(refreshToken);
 
 		// then
 		assertAll(

server/src/test/java/com/ticketing/server/user/service/UserApisServiceImplTest.java

@@ -11,9 +11,9 @@ import com.ticketing.server.payment.application.response.SimplePaymentsResponse;
 import com.ticketing.server.payment.service.dto.CreatePaymentDTO;
 import com.ticketing.server.payment.service.dto.SimplePaymentDTO;
 import com.ticketing.server.user.api.PaymentClient;
-import com.ticketing.server.user.application.response.PaymentsResponse;
 import com.ticketing.server.user.domain.User;
 import com.ticketing.server.user.domain.UserGrade;
+import com.ticketing.server.user.service.dto.PaymentsDTO;
 import com.ticketing.server.user.service.interfaces.UserService;
 import java.util.Arrays;
 import java.util.Collections;
@@ -53,12 +53,12 @@ class UserApisServiceImplTest {
 		when(paymentClient.getPayments(any())).thenReturn(new SimplePaymentsResponse(1L, Collections.emptyList()));
 
 		// when
-		PaymentsResponse paymentDetails = userApisService.findPaymentsByEmail("ticketing@gmail.com");
+		PaymentsDTO paymentsDto = userApisService.findPaymentsByEmail("ticketing@gmail.com");
 
 		// then
 		assertAll(
-			() -> assertThat(paymentDetails.getEmail()).isEqualTo("ticketing@gmail.com")
-			, () -> assertThat(paymentDetails.getPayments()).hasSize(0)
+			() -> assertThat(paymentsDto.getEmail()).isEqualTo("ticketing@gmail.com")
+			, () -> assertThat(paymentsDto.getPayments()).isEmpty()
 		);
 	}
 
@@ -77,12 +77,12 @@ class UserApisServiceImplTest {
 		when(paymentClient.getPayments(any())).thenReturn(new SimplePaymentsResponse(1L, payments));
 
 		// when
-		PaymentsResponse paymentDetails = userApisService.findPaymentsByEmail("ticketing@gmail.com");
+		PaymentsDTO patmentsDto = userApisService.findPaymentsByEmail("ticketing@gmail.com");
 
 		// then
 		assertAll(
-			() -> assertThat(paymentDetails.getEmail()).isEqualTo("ticketing@gmail.com")
-			, () -> assertThat(paymentDetails.getPayments()).hasSize(2)
+			() -> assertThat(patmentsDto.getEmail()).isEqualTo("ticketing@gmail.com")
+			, () -> assertThat(patmentsDto.getPayments()).hasSize(2)
 		);
 	}
 

server/src/test/java/com/ticketing/server/user/service/UserServiceImplTest.java

@@ -13,8 +13,11 @@ 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.DeleteUserDTOTest;
+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 java.util.Optional;
@@ -72,10 +75,10 @@ class UserServiceImplTest {
 		when(sequenceGenerator.generateId()).thenReturn(123L);
 
 		// when
-		User user = userService.register(signUpDto);
+		CreatedUserDTO createdUserDto = userService.register(signUpDto);
 
 		// then
-		assertThat(user).isNotNull();
+		assertThat(createdUserDto).isNotNull();
 	}
 
 	@Test
@@ -97,10 +100,10 @@ class UserServiceImplTest {
 		when(userRepository.findByEmailAndDeletedAtNull("ticketing@gmail.com")).thenReturn(Optional.of(user));
 
 		// when
-		User user = userService.delete(deleteUserDto);
+		DeletedUserDTO deletedUserDto = userService.delete(deleteUserDto);
 
 		// then
-		assertThat(user.getDeletedAt()).isNotNull();
+		assertThat(deletedUserDto.getDeletedAt()).isNotNull();
 	}
 
 	@Test
@@ -122,10 +125,10 @@ class UserServiceImplTest {
 		when(userRepository.findByEmailAndDeletedAtNull("ticketing@gmail.com")).thenReturn(Optional.of(user));
 
 		// when
-		User user = userService.changePassword(changePasswordDto);
+		ChangedPasswordUserDTO changedUserDto = userService.changePassword(changePasswordDto);
 
 		// then
-		assertThat(user).isNotNull();
+		assertThat(changedUserDto).isNotNull();
 	}
 
 	@Test