Compare commits

..

3 Commits

Author SHA1 Message Date
손창현
994db8afad fix: 하단 공백 추가 2022-06-07 20:58:22 +09:00
손창현
dabee5c844 add: json-simple dependency 2022-06-07 20:57:32 +09:00
손창현
24c8039031 feat: TMDBServiceImplTest - get [now_playing] movie list in Korean 2022-06-07 20:36:39 +09:00
117 changed files with 573 additions and 2664 deletions

View File

@@ -1,5 +1,5 @@
# 🍿 Ticketing
영화 예매 사이트를 대용량 트래픽에 대응할 수 있도록 설계.
영화 예매 서비스
<br/>
@@ -8,43 +8,19 @@
- 기획 및 설계 : 22.04.13 ~
- 프로젝트 구현 :
<br/>
## 🎯 프로젝트 주요 관심사
- OOP(객체 지향 프로그래밍)의 장점을 최대한 활용
- 테스트 코드를 통한 믿을 수 있는 코드 작성
- 대용량 트래픽을 고려한 확장 가능한 설계 및 성능 튜닝
- 코드리뷰를 통해 코드 품질 향상
- 코드 컨벤션 준수하여 코드 통일성 유지
<br/><br/>
<br/>
## 🎯 프로젝트 목표
## 🛠 기술스택
- Java 11
- Spring Boot 2.6.7 (당시 최신 GA 버전)
- Gradle Kotlin DSL
- Spring Security
- Junit 5
- Hibernate / SpringJPA
- MySQL 8.0
- Redis
<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/>
<br/><br/>
## 🧩 ERD
``` mermaid
erDiagram
MOVIE ||--o{ MOVIE_TIME : ""
MOVIE ||--o{ MOVIE_TIMES : ""
MOVIE {
bigint id PK "영화 ID"
varchar title "영화제목"
@@ -52,7 +28,7 @@ erDiagram
datetime created_at "등록일시"
datetime updated_at "수정일시"
}
THEATER ||--o{ MOVIE_TIME : ""
THEATER ||--o{ MOVIE_TIMES : ""
THEATER ||--|{ SEAT : ""
THEATER {
bigint id PK "상영관 ID"
@@ -70,11 +46,12 @@ erDiagram
datetime created_at "등록일시"
datetime updated_at "수정일시"
}
MOVIE_TIME ||--o{ TICKET : ""
MOVIE_TIME {
MOVIE_TIMES ||--o{ TICKET : ""
MOVIE_TIMES {
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 "종료 시간"
@@ -84,8 +61,8 @@ erDiagram
TICKET {
bigint id PK "티켓 ID"
bigint seat_id FK "좌석 ID"
bigint movie_time_id FK "상영시간표 ID"
bigint payment_id "결제 ID"
bigint movie_times_id FK "상영시간표 ID"
bigint payment_id FK "결제 ID"
varchar status "상태 - 구매가능/예약진행중/판매완료"
int ticket_price "가격"
datetime created_at "등록일시"
@@ -94,8 +71,7 @@ erDiagram
TICKET }|--|| PAYMENT : ""
PAYMENT {
bigint id PK "결제 ID"
bigint user_id "유저ID"
varchar movie_title "영화제목"
bigint user_id FK "유저ID"
varchar type "결제 타입 - 예) 네이버페이, 카카오페이"
varchar status "상태 - 완료/환불/실패"
varchar failed_message "실패사유 - 컬럼명을 알아보기 쉬운가?"
@@ -118,3 +94,5 @@ erDiagram
datetime updated_at "수정일시"
}
```
<br/><br/>

View File

@@ -1,7 +1,7 @@
plugins {
java
id("org.springframework.boot") version "2.6.7"
id("io.spring.dependency-management") version "1.0.11.RELEASE"
java
id("org.springframework.boot") version "2.6.7"
id("io.spring.dependency-management") version "1.0.11.RELEASE"
}
group = "com.ticketing"
@@ -9,80 +9,59 @@ version = "0.0.1-SNAPSHOT"
val javaVersion = JavaVersion.VERSION_11
java {
sourceCompatibility = javaVersion
targetCompatibility = javaVersion
sourceCompatibility = javaVersion
targetCompatibility = javaVersion
}
configurations {
compileOnly {
extendsFrom(configurations.annotationProcessor.get())
}
compileOnly {
extendsFrom(configurations.annotationProcessor.get())
}
}
repositories {
mavenCentral()
mavenCentral()
}
dependencies {
implementation("org.springframework.boot:spring-boot-starter-data-jpa")
implementation("org.springframework.boot:spring-boot-starter-security")
implementation("org.springframework.boot:spring-boot-starter-validation")
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.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.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")
implementation("org.springframework.boot:spring-boot-starter-data-jpa")
implementation("org.springframework.boot:spring-boot-starter-security")
implementation("org.springframework.boot:spring-boot-starter-validation")
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("io.springfox:springfox-swagger2: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.googlecode.json-simple:json-simple:1.1.1")
modules {
module("org.springframework.boot:spring-boot-starter-logging") {
replacedBy("org.springframework.boot:spring-boot-starter-log4j2", "Use Log4j2 instead of Logback")
}
}
modules {
module("org.springframework.boot:spring-boot-starter-logging") {
replacedBy("org.springframework.boot:spring-boot-starter-log4j2", "Use Log4j2 instead of Logback")
}
}
compileOnly("org.projectlombok:lombok")
runtimeOnly("mysql:mysql-connector-java")
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")
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")
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")
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")
annotationProcessor("org.projectlombok:lombok")
annotationProcessor("org.springframework.boot:spring-boot-configuration-processor")
testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.8.1")
testImplementation("org.springframework.boot:spring-boot-starter-test")
testImplementation("org.springframework.security:spring-security-test")
}
tasks.withType<Test> {
useJUnitPlatform()
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) }

View File

@@ -1,75 +0,0 @@
package com.ticketing.server.global.redis;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertAll;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class RefreshRedisRepositoryTest {
@Autowired
RefreshRedisRepository refreshRedisRepository;
@AfterEach
void tearDown() {
refreshRedisRepository.deleteAll();
}
@Test
@DisplayName("기본 등록 및 조회기능")
void saveAndFind() {
// given
RefreshToken refreshToken = new RefreshToken("ticketing@gmail.com", "refreshToken");
// when
refreshRedisRepository.save(refreshToken);
// then
RefreshToken findRefreshToken = refreshRedisRepository.findById(refreshToken.getId()).get();
assertAll(
() -> assertThat(findRefreshToken.getEmail()).isEqualTo("ticketing@gmail.com")
, () -> assertThat(findRefreshToken.getToken()).isEqualTo("refreshToken")
);
}
@Test
@DisplayName("기본 등록 및 이메일 조회")
void saveAndFindByEmail() {
// given
RefreshToken refreshToken = new RefreshToken("ticketing@gmail.com", "refreshToken");
// when
refreshRedisRepository.save(refreshToken);
// then
RefreshToken findRefreshToken = refreshRedisRepository.findByEmail(refreshToken.getEmail()).get();
assertAll(
() -> assertThat(findRefreshToken.getEmail()).isEqualTo("ticketing@gmail.com")
, () -> assertThat(findRefreshToken.getToken()).isEqualTo("refreshToken")
);
}
@Test
@DisplayName("기본 등록 및 수정기능")
void saveAndSave() {
// given
RefreshToken refreshToken = new RefreshToken("ticketing@gmail.com", "refreshToken");
refreshRedisRepository.save(refreshToken);
Long id = refreshToken.getId();
// when
RefreshToken savedRefreshToken = refreshRedisRepository.findById(id).get();
savedRefreshToken.changeToken("refreshToken2");
refreshRedisRepository.save(savedRefreshToken);
// then
RefreshToken lastSavedRefreshToken = refreshRedisRepository.findById(id).get();
assertThat(lastSavedRefreshToken.getToken()).isEqualTo("refreshToken2");
}
}

View File

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

View File

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

View File

@@ -1,6 +1,6 @@
package com.ticketing.server;
import com.ticketing.server.global.security.jwt.JwtProperties;
import com.ticketing.server.global.jwt.JwtProperties;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;

View File

@@ -1,28 +1,14 @@
package com.ticketing.server.global.config;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import lombok.RequiredArgsConstructor;
import org.springframework.boot.actuate.autoconfigure.endpoint.web.CorsEndpointProperties;
import org.springframework.boot.actuate.autoconfigure.endpoint.web.WebEndpointProperties;
import org.springframework.boot.actuate.autoconfigure.web.server.ManagementPortType;
import org.springframework.boot.actuate.endpoint.ExposableEndpoint;
import org.springframework.boot.actuate.endpoint.web.EndpointLinksResolver;
import org.springframework.boot.actuate.endpoint.web.EndpointMapping;
import org.springframework.boot.actuate.endpoint.web.EndpointMediaTypes;
import org.springframework.boot.actuate.endpoint.web.ExposableWebEndpoint;
import org.springframework.boot.actuate.endpoint.web.WebEndpointsSupplier;
import org.springframework.boot.actuate.endpoint.web.annotation.ControllerEndpointsSupplier;
import org.springframework.boot.actuate.endpoint.web.annotation.ServletEndpointsSupplier;
import org.springframework.boot.actuate.endpoint.web.servlet.WebMvcEndpointHandlerMapping;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.util.StringUtils;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.ApiKey;
import springfox.documentation.service.AuthorizationScope;
import springfox.documentation.service.SecurityReference;
@@ -36,29 +22,27 @@ import springfox.documentation.swagger.web.UiConfigurationBuilder;
@RequiredArgsConstructor
public class SwaggerConfig {
public static final String SECURITY_SCHEMA_NAME = "Authorization";
public static final String AUTHORIZATION_SCOPE_GLOBAL = "global";
public static final String AUTHORIZATION_SCOPE_GLOBAL_DESC = "accessEverything";
@Bean
public Docket api() {
return new Docket(DocumentationType.OAS_30).useDefaultResponseMessages(false).select()
.apis(RequestHandlerSelectors.any()).paths(PathSelectors.ant("/api/**")).build()
return new Docket(DocumentationType.OAS_30)
.useDefaultResponseMessages(false)
.select()
.apis(RequestHandlerSelectors.any())
.paths(PathSelectors.ant("/api/**")).build()
.apiInfo(apiInfo())
.securityContexts(Arrays.asList(securityContext()))
.securitySchemes(Arrays.asList(apiKey()));
}
@Bean
public WebMvcEndpointHandlerMapping webEndpointServletHandlerMapping(WebEndpointsSupplier webEndpointsSupplier, ServletEndpointsSupplier servletEndpointsSupplier, ControllerEndpointsSupplier controllerEndpointsSupplier, EndpointMediaTypes endpointMediaTypes, CorsEndpointProperties corsProperties, WebEndpointProperties webEndpointProperties, Environment environment) {
List<ExposableEndpoint<?>> allEndpoints = new ArrayList<>();
Collection<ExposableWebEndpoint> webEndpoints = webEndpointsSupplier.getEndpoints();
allEndpoints.addAll(webEndpoints);
allEndpoints.addAll(servletEndpointsSupplier.getEndpoints());
allEndpoints.addAll(controllerEndpointsSupplier.getEndpoints());
String basePath = webEndpointProperties.getBasePath();
EndpointMapping endpointMapping = new EndpointMapping(basePath);
boolean shouldRegisterLinksMapping = this.shouldRegisterLinksMapping(webEndpointProperties, environment, basePath);
return new WebMvcEndpointHandlerMapping(endpointMapping, webEndpoints, endpointMediaTypes, corsProperties.toCorsConfiguration(), new EndpointLinksResolver(allEndpoints, basePath), shouldRegisterLinksMapping, null);
}
private boolean shouldRegisterLinksMapping(WebEndpointProperties webEndpointProperties, Environment environment, String basePath) {
return webEndpointProperties.getDiscovery().isEnabled() && (StringUtils.hasText(basePath) || ManagementPortType.get(environment).equals(ManagementPortType.DIFFERENT));
private ApiInfo apiInfo() {
return new ApiInfoBuilder()
.title("Ticketing REST API Document")
.version("v1")
.description("Ticketing REST API 문서").build();
}
private ApiKey apiKey() {
@@ -69,10 +53,6 @@ public class SwaggerConfig {
return SecurityContext.builder().securityReferences(defaultAuth()).build();
}
public static final String SECURITY_SCHEMA_NAME = "Authorization";
public static final String AUTHORIZATION_SCOPE_GLOBAL = "global";
public static final String AUTHORIZATION_SCOPE_GLOBAL_DESC = "accessEverything";
private List<SecurityReference> defaultAuth() {
AuthorizationScope authorizationScope = new AuthorizationScope(AUTHORIZATION_SCOPE_GLOBAL,
AUTHORIZATION_SCOPE_GLOBAL_DESC);

View File

@@ -28,6 +28,4 @@ public abstract class AbstractEntity {
@LastModifiedDate
private LocalDateTime updatedAt;
private LocalDateTime deletedAt;
}

View File

@@ -0,0 +1,9 @@
package com.ticketing.server.global.exception;
public class AlreadyDeletedException extends RuntimeException {
public AlreadyDeletedException(String message) {
super(message);
}
}

View File

@@ -1,77 +0,0 @@
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.NOT_FOUND;
import lombok.AllArgsConstructor;
import lombok.Getter;
import org.springframework.http.HttpStatus;
@Getter
@AllArgsConstructor
public enum ErrorCode {
/* 400 BAD_REQUEST : 잘못된 요청 */
MISMATCH_PASSWORD(BAD_REQUEST, "비밀번호가 일치하지 않습니다."),
TOKEN_TYPE(BAD_REQUEST, "토큰 타입이 올바르지 않습니다."),
UNAVAILABLE_REFRESH_TOKEN(BAD_REQUEST, "사용할 수 없는 토큰 입니다."),
/* 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, "리프레쉬 토큰을 찾을 수 없습니다."),
/* 409 CONFLICT : Resource 의 현재 상태와 충돌. 보통 중복된 데이터 존재 */
DUPLICATE_EMAIL(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);
}
/* 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);
}
/* 409 CONFLICT : Resource 의 현재 상태와 충돌. 보통 중복된 데이터 존재 */
public static TicketingException throwDuplicateEmail() {
throw new TicketingException(DUPLICATE_EMAIL);
}
public static TicketingException throwDuplicateMovie() {
throw new TicketingException(DUPLICATE_MOVIE);
}
public static TicketingException throwDeletedEmail() {
throw new TicketingException(DELETED_EMAIL);
}
}

View File

@@ -1,35 +0,0 @@
package com.ticketing.server.global.exception;
import java.util.List;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import org.springframework.http.HttpStatus;
@Getter
@EqualsAndHashCode
public class ErrorResponse {
private final HttpStatus status;
private final String message;
private final List<String> errors;
public ErrorResponse(HttpStatus status, String message, List<String> errors) {
this.status = status;
this.message = message;
this.errors = errors;
}
public ErrorResponse(HttpStatus status, String message, String error) {
this.status = status;
this.message = message;
this.errors = List.of(error);
}
public static ErrorResponse toErrorResponse(ErrorCode errorCode) {
return new ErrorResponse(
errorCode.getHttpStatus(),
errorCode.name(),
errorCode.getDetail());
}
}

View File

@@ -1,246 +0,0 @@
package com.ticketing.server.global.exception;
import static org.springframework.http.HttpStatus.BAD_REQUEST;
import static org.springframework.http.HttpStatus.FORBIDDEN;
import static org.springframework.http.HttpStatus.INTERNAL_SERVER_ERROR;
import static org.springframework.http.HttpStatus.METHOD_NOT_ALLOWED;
import static org.springframework.http.HttpStatus.NOT_FOUND;
import static org.springframework.http.HttpStatus.UNAUTHORIZED;
import static org.springframework.http.HttpStatus.UNSUPPORTED_MEDIA_TYPE;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import javax.validation.ConstraintViolation;
import javax.validation.ConstraintViolationException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.TypeMismatchException;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.core.AuthenticationException;
import org.springframework.validation.BindException;
import org.springframework.validation.FieldError;
import org.springframework.validation.ObjectError;
import org.springframework.web.HttpMediaTypeNotSupportedException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
import org.springframework.web.multipart.support.MissingServletRequestPartException;
import org.springframework.web.servlet.NoHandlerFoundException;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
/* 400 START */
/**
* Valid 유효성 검사 실패
*/
@Override
protected ResponseEntity<Object> handleMethodArgumentNotValid(
MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
log.error("MethodArgumentNotValidException :: ", ex);
List<String> errors = generateErrors(ex);
ErrorResponse response = new ErrorResponse(BAD_REQUEST, ex.getLocalizedMessage(), errors);
return handleExceptionInternal(ex, response, headers, response.getStatus(), request);
}
/***
* ModelAttribute 으로 binding error 발생
*/
@Override
protected ResponseEntity<Object> handleBindException(
BindException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
log.error("BindException :: ", ex);
List<String> errors = generateErrors(ex);
ErrorResponse response = new ErrorResponse(BAD_REQUEST, ex.getLocalizedMessage(), errors);
return handleExceptionInternal(ex, response, headers, response.getStatus(), request);
}
/**
* 잘못된 유형으로 Bean 속성 설정
*/
@Override
protected ResponseEntity<Object> handleTypeMismatch(
TypeMismatchException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
log.error("TypeMismatchException :: ", ex);
String error = ex.getValue() + " value for " + ex.getPropertyName() + " should be of type " + ex.getRequiredType();
ErrorResponse response = new ErrorResponse(BAD_REQUEST, ex.getLocalizedMessage(), error);
return ResponseEntity.status(response.getStatus()).headers(headers).body(response);
}
/**
* multipart/form-data 요청 실패
*/
@Override
protected ResponseEntity<Object> handleMissingServletRequestPart(
MissingServletRequestPartException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
log.error("MissingServletRequestPartException :: ", ex);
String error = ex.getRequestPartName() + " part is missing";
ErrorResponse response = new ErrorResponse(BAD_REQUEST, ex.getLocalizedMessage(), error);
return ResponseEntity.status(response.getStatus()).headers(headers).body(response);
}
/**
* 필수 인수 누락
*/
@Override
protected ResponseEntity<Object> handleMissingServletRequestParameter(
MissingServletRequestParameterException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
log.error("MissingServletRequestParameterException :: ", ex);
String error = ex.getParameterName() + " parameter is missing";
ErrorResponse response = new ErrorResponse(BAD_REQUEST, ex.getLocalizedMessage(), error);
return ResponseEntity.status(response.getStatus()).headers(headers).body(response);
}
/**
* 인수가 예상한 형식이 아닐 시
*/
@ExceptionHandler(value = MethodArgumentTypeMismatchException.class)
protected ResponseEntity<Object> handleMethodArgumentTypeMismatch(MethodArgumentTypeMismatchException ex) {
log.error("MethodArgumentTypeMismatchException :: ", ex);
String error = ex.getName() + " should be of type " + Objects.requireNonNull(ex.getRequiredType()).getName();
ErrorResponse response = new ErrorResponse(BAD_REQUEST, ex.getLocalizedMessage(), error);
return ResponseEntity.status(response.getStatus()).headers(new HttpHeaders()).body(response);
}
/**
* 제약 조건 위반
*/
@ExceptionHandler(value = ConstraintViolationException.class)
protected ResponseEntity<Object> handleConstraintViolation(ConstraintViolationException ex) {
log.error("ConstraintViolationException :: ", ex);
List<String> errors = new ArrayList<>();
for (ConstraintViolation<?> violation : ex.getConstraintViolations()) {
errors.add(violation.getRootBeanClass().getName() + " " + violation.getPropertyPath() + ": " + violation.getMessage());
}
ErrorResponse response = new ErrorResponse(BAD_REQUEST, ex.getLocalizedMessage(), errors);
return ResponseEntity.status(response.getStatus()).headers(new HttpHeaders()).body(response);
}
/* 400 END */
/**
* 404 발생
*/
@Override
protected ResponseEntity<Object> handleNoHandlerFoundException(
NoHandlerFoundException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
log.error("NoHandlerFoundException :: ", ex);
String error = "No handler found for " + ex.getHttpMethod() + " " + ex.getRequestURL();
ErrorResponse response = new ErrorResponse(NOT_FOUND, ex.getLocalizedMessage(), error);
return ResponseEntity.status(response.getStatus()).headers(headers).body(response);
}
/**
* 지원하지 않는 HTTP 메서드로 요청 405
*/
@Override
protected ResponseEntity<Object> handleHttpRequestMethodNotSupported(
HttpRequestMethodNotSupportedException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
log.error("HttpRequestMethodNotSupportedException :: ", ex);
StringBuilder builder = new StringBuilder();
builder.append(ex.getMethod());
builder.append(" method is not supported for this request. Supported methods are ");
Set<HttpMethod> supportedHttpMethods = ex.getSupportedHttpMethods();
if (supportedHttpMethods != null) {
supportedHttpMethods.forEach(t -> builder.append(t).append(" "));
}
ErrorResponse response = new ErrorResponse(METHOD_NOT_ALLOWED, ex.getLocalizedMessage(), builder.toString());
return ResponseEntity.status(response.getStatus()).headers(new HttpHeaders()).body(response);
}
/**
* 지원되지 않는 미디어 유형으로 요청 415
*/
@Override
protected ResponseEntity<Object> handleHttpMediaTypeNotSupported(
HttpMediaTypeNotSupportedException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
log.error("HttpMediaTypeNotSupportedException :: ", ex);
StringBuilder builder = new StringBuilder();
builder.append(ex.getContentType());
builder.append(" media type is not supported. Supported media types are ");
ex.getSupportedMediaTypes().forEach(t -> builder.append(t).append(" "));
ErrorResponse response = new ErrorResponse(UNSUPPORTED_MEDIA_TYPE, ex.getLocalizedMessage(), builder.substring(0, builder.length() - 2));
return ResponseEntity.status(response.getStatus()).headers(new HttpHeaders()).body(response);
}
/**
* 특정 핸들러 없는 모든 예외 500
*/
@ExceptionHandler(value = Exception.class)
protected ResponseEntity<Object> handleAll(Exception ex) {
log.error("Exception :: ", ex);
ErrorResponse response = new ErrorResponse(INTERNAL_SERVER_ERROR, ex.getLocalizedMessage(), "오류가 발생했습니다.");
return ResponseEntity.status(response.getStatus()).headers(new HttpHeaders()).body(response);
}
/**
* 접근 권한이 없을 때
*/
@ExceptionHandler(value = AccessDeniedException.class)
protected ResponseEntity<ErrorResponse> handleAccessDeniedException(Exception ex) {
log.error("AccessDeniedException :: ", ex);
ErrorResponse response = new ErrorResponse(FORBIDDEN, ex.getLocalizedMessage(), "접근 권한이 없습니다.");
return ResponseEntity.status(response.getStatus()).headers(new HttpHeaders()).body(response);
}
/**
* 인증 정보가 없을 때
*/
@ExceptionHandler(value = AuthenticationException.class)
protected ResponseEntity<ErrorResponse> handleAuthenticationException(Exception ex) {
log.error("AuthenticationException :: ", ex);
ErrorResponse response = new ErrorResponse(UNAUTHORIZED, ex.getLocalizedMessage(), "로그인 후 이용하실 수 있습니다.");
return ResponseEntity.status(response.getStatus()).headers(new HttpHeaders()).body(response);
}
/**
* 커스텀 예외 발생 시
*/
@ExceptionHandler(value = TicketingException.class)
protected ResponseEntity<ErrorResponse> ticketingException(TicketingException ex) {
log.error("TicketingException :: ", ex);
ErrorCode errorCode = ex.getErrorCode();
return ResponseEntity.status(errorCode.getHttpStatus()).body(ErrorResponse.toErrorResponse(errorCode));
}
private List<String> generateErrors(BindException ex) {
List<String> errors = new ArrayList<>();
List<ObjectError> allErrors = ex.getBindingResult().getAllErrors();
for (ObjectError error : allErrors) {
errors.add(((FieldError) error).getField() + ": " + error.getDefaultMessage());
}
return errors;
}
}

View File

@@ -0,0 +1,11 @@
package com.ticketing.server.global.exception;
public class NotFoundEmailException extends IllegalArgumentException {
private static final String MESSAGE = "존재하지 않는 이메일 입니다.";
public NotFoundEmailException() {
super(MESSAGE);
}
}

View File

@@ -0,0 +1,11 @@
package com.ticketing.server.global.exception;
public class PasswordMismatchException extends RuntimeException {
private static final String MESSAGE = "패스워드가 일치하지 않습니다";
public PasswordMismatchException() {
super(MESSAGE);
}
}

View File

@@ -1,12 +0,0 @@
package com.ticketing.server.global.exception;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public class TicketingException extends RuntimeException {
private final ErrorCode errorCode;
}

View File

@@ -5,23 +5,19 @@ import java.util.Properties;
import org.springframework.beans.factory.config.YamlPropertiesFactoryBean;
import org.springframework.core.env.PropertiesPropertySource;
import org.springframework.core.env.PropertySource;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.EncodedResource;
import org.springframework.core.io.support.PropertySourceFactory;
import org.springframework.lang.Nullable;
import org.springframework.util.StringUtils;
public class YamlPropertySourceFactory implements PropertySourceFactory {
@Override
public PropertySource<?> createPropertySource(@Nullable String name, EncodedResource resource) {
Properties yamlProperties = loadYamlProperties(resource);
String sourceName = StringUtils.hasText(name) ? name : resource.getResource().getFilename();
return new PropertiesPropertySource(Objects.requireNonNull(sourceName), Objects.requireNonNull(yamlProperties));
}
public PropertySource<?> createPropertySource(String name, EncodedResource encodedResource) {
Resource resource = encodedResource.getResource();
YamlPropertiesFactoryBean factoryBean = new YamlPropertiesFactoryBean();
factoryBean.setResources(resource);
private Properties loadYamlProperties(EncodedResource resource) {
YamlPropertiesFactoryBean factory = new YamlPropertiesFactoryBean();
factory.setResources(resource.getResource());
return factory.getObject();
Properties properties = factoryBean.getObject();
return new PropertiesPropertySource(Objects.requireNonNull(resource.getFilename()), Objects.requireNonNull(properties));
}
}

View File

@@ -1,4 +1,4 @@
package com.ticketing.server.global.security.jwt;
package com.ticketing.server.global.jwt;
import java.io.IOException;
import javax.servlet.FilterChain;
@@ -17,10 +17,12 @@ import org.springframework.web.filter.OncePerRequestFilter;
public class JwtFilter extends OncePerRequestFilter {
private final JwtProvider tokenProvider;
private final JwtProperties jwtProperties;
private final String accessHeader;
private final String tokenPrefix;
public JwtFilter(JwtProperties jwtProperties, JwtProvider tokenProvider) {
this.jwtProperties = jwtProperties;
this.accessHeader = jwtProperties.getAccessHeader();
this.tokenPrefix = jwtProperties.getPrefix();
this.tokenProvider = tokenProvider;
}
@@ -38,10 +40,11 @@ public class JwtFilter extends OncePerRequestFilter {
}
private String resolveToken(HttpServletRequest request) {
String bearerToken = request.getHeader(jwtProperties.getAccessHeader());
if (StringUtils.hasText(bearerToken) && jwtProperties.hasTokenStartsWith(bearerToken)) {
String bearerToken = request.getHeader(accessHeader);
if (StringUtils.hasText(bearerToken) && bearerToken.startsWith(tokenPrefix)) {
return bearerToken.substring(7);
}
return null;
}

View File

@@ -1,4 +1,4 @@
package com.ticketing.server.global.security.jwt;
package com.ticketing.server.global.jwt;
import com.ticketing.server.global.factory.YamlPropertySourceFactory;
import lombok.Getter;
@@ -10,18 +10,13 @@ import org.springframework.context.annotation.PropertySource;
@Getter
@RequiredArgsConstructor
@ConstructorBinding
@ConfigurationProperties(value = "jwt")
@ConfigurationProperties("jwt")
@PropertySource(value = "classpath:application.yml", factory = YamlPropertySourceFactory.class)
public class JwtProperties {
private final String accessHeader;
private final String refreshHeader;
private final String prefix;
private final String secretKey;
private final Integer accessTokenValidityInSeconds;
private final Integer refreshTokenValidityInSeconds;
private final Integer tokenValidityInSeconds;
public boolean hasTokenStartsWith(String token) {
return token.startsWith(prefix);
}
}

View File

@@ -1,11 +1,14 @@
package com.ticketing.server.global.security.jwt;
package com.ticketing.server.global.jwt;
import com.ticketing.server.user.application.response.TokenDto;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.MalformedJwtException;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.UnsupportedJwtException;
import io.jsonwebtoken.io.Decoders;
import io.jsonwebtoken.security.Keys;
import io.jsonwebtoken.security.SecurityException;
import java.security.Key;
import java.util.Arrays;
import java.util.Date;
@@ -28,53 +31,29 @@ public class JwtProvider {
private static final String AUTHORITIES_KEY = "auth";
private static final String AUTHORITIES_DELIMITER = ",";
private final long tokenValidityInMilliseconds;
private final Key key;
private final String prefix;
private final long accessTokenValidityInMilliseconds;
private final long refreshTokenValidityInMilliseconds;
public JwtProvider(JwtProperties jwtProperties) {
this.tokenValidityInMilliseconds = jwtProperties.getTokenValidityInSeconds();
byte[] keyBytes = Decoders.BASE64.decode(jwtProperties.getSecretKey());
this.key = Keys.hmacShaKeyFor(keyBytes);
this.prefix = jwtProperties.getPrefix();
this.accessTokenValidityInMilliseconds = jwtProperties.getAccessTokenValidityInSeconds() * 1000L;
this.refreshTokenValidityInMilliseconds = jwtProperties.getRefreshTokenValidityInSeconds() * 1000L;
}
public TokenDto generateTokenDto(Authentication authentication) {
String accessToken = createAccessToken(authentication);
String refreshToken = createRefreshToken(authentication);
long expiresIn = accessTokenValidityInMilliseconds / 1000L;
return TokenDto.of(accessToken, refreshToken, prefix, expiresIn);
}
private String createAccessToken(Authentication authentication) {
// 만료시간 계산
long now = (new Date()).getTime();
Date accessTokenExpiresIn = new Date(now + this.accessTokenValidityInMilliseconds);
return createToken(authentication, accessTokenExpiresIn);
}
private String createRefreshToken(Authentication authentication) {
// 만료시간 계산
long now = (new Date()).getTime();
Date refreshTokenExpiresIn = new Date(now + this.refreshTokenValidityInMilliseconds);
return createToken(authentication, refreshTokenExpiresIn);
}
private String createToken(Authentication authentication, Date expiration) {
public String createToken(Authentication authentication) {
// 권한 정보 가져오기
String authorities = generateStringToAuthorities(authentication);
// 만료시간 계산
long now = new Date().getTime();
Date accessTokenExpiresIn = new Date(now + this.tokenValidityInMilliseconds);
// JWT 생성
return Jwts.builder()
.setSubject(authentication.getName()) // email
.claim(AUTHORITIES_KEY, authorities) // payload
.setExpiration(expiration) // 만료일
.setExpiration(accessTokenExpiresIn) // 만료일
.signWith(key, SignatureAlgorithm.HS512) // 서명
.compact();
}
@@ -96,7 +75,6 @@ public class JwtProvider {
// 토큰 복호화
Claims claims = parseClaims(token);
// 권한조회
List<SimpleGrantedAuthority> authorities =
Arrays.stream(claims.get(AUTHORITIES_KEY).toString().split(AUTHORITIES_DELIMITER))
.map(SimpleGrantedAuthority::new)
@@ -107,12 +85,25 @@ public class JwtProvider {
}
public boolean validateToken(String token) {
parseClaims(token);
return true;
try {
parseClaims(token);
return true;
} catch (SecurityException | MalformedJwtException exception) {
log.info("잘못된 JWT 서명입니다.");
} catch (ExpiredJwtException e) {
log.info("잘못된 JWT 토큰입니다.");
} catch (UnsupportedJwtException e) {
log.info("지원되지 않는 JWT 토큰입니다.");
} catch (IllegalArgumentException e) {
log.info("JWT 토큰이 잘못되었습니다.");
}
return false;
}
private Claims parseClaims(String token) {
return Jwts.parserBuilder()
return Jwts
.parserBuilder()
.setSigningKey(key)
.build()
.parseClaimsJws(token)

View File

@@ -1,4 +1,4 @@
package com.ticketing.server.global.security.jwt;
package com.ticketing.server.global.jwt;
import lombok.RequiredArgsConstructor;
import org.springframework.security.config.annotation.SecurityConfigurerAdapter;

View File

@@ -1,26 +1,17 @@
package com.ticketing.server.global.security.jwt.handle;
package com.ticketing.server.global.jwt.handle;
import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerExceptionResolver;
@Component("JwtAccessDeniedHandler")
@Component
public class JwtAccessDeniedHandler implements AccessDeniedHandler {
private final HandlerExceptionResolver resolver;
public JwtAccessDeniedHandler(@Qualifier("handlerExceptionResolver") HandlerExceptionResolver resolver) {
this.resolver = resolver;
}
@Override
public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException {
response.sendError(HttpServletResponse.SC_FORBIDDEN);
resolver.resolveException(request, response, null, accessDeniedException);
}
}

View File

@@ -0,0 +1,17 @@
package com.ticketing.server.global.jwt.handle;
import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;
@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {
@Override
public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException {
response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
}
}

View File

@@ -1,44 +0,0 @@
package com.ticketing.server.global.redis;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.repository.configuration.EnableRedisRepositories;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
@Configuration
@EnableRedisRepositories
public class RedisConfig {
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.port}")
private int port;
@Bean
public RedisConnectionFactory redisConnectionFactory() {
return new LettuceConnectionFactory(host, port);
}
@Bean
public RedisTemplate<String, Object> redisTemplate() {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory());
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(new StringRedisSerializer());
return redisTemplate;
}
@Bean
public PlatformTransactionManager transactionManager() {
return new JpaTransactionManager();
}
}

View File

@@ -1,10 +0,0 @@
package com.ticketing.server.global.redis;
import java.util.Optional;
import org.springframework.data.repository.CrudRepository;
public interface RefreshRedisRepository extends CrudRepository<RefreshToken, Long> {
Optional<RefreshToken> findByEmail(String email);
}

View File

@@ -1,35 +0,0 @@
package com.ticketing.server.global.redis;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;
import org.springframework.data.redis.core.RedisHash;
import org.springframework.data.redis.core.index.Indexed;
@Getter
@RedisHash("RefreshToken")
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class RefreshToken {
@Id
@GeneratedValue
@Column(name = "refresh_token_id")
private Long id;
@Indexed
private String email;
private String token;
public RefreshToken(String email, String token) {
this.email = email;
this.token = token;
}
public void changeToken(String token) {
this.token = token;
}
}

View File

@@ -1,56 +0,0 @@
package com.ticketing.server.global.security;
import com.ticketing.server.user.domain.UserGrade;
import java.util.ArrayList;
import java.util.List;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.access.AccessDecisionManager;
import org.springframework.security.access.AccessDecisionVoter;
import org.springframework.security.access.annotation.Jsr250Voter;
import org.springframework.security.access.expression.method.ExpressionBasedPreInvocationAdvice;
import org.springframework.security.access.hierarchicalroles.RoleHierarchy;
import org.springframework.security.access.hierarchicalroles.RoleHierarchyImpl;
import org.springframework.security.access.prepost.PreInvocationAuthorizationAdviceVoter;
import org.springframework.security.access.vote.AffirmativeBased;
import org.springframework.security.access.vote.AuthenticatedVoter;
import org.springframework.security.access.vote.RoleHierarchyVoter;
import org.springframework.security.access.vote.RoleVoter;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.method.configuration.GlobalMethodSecurityConfiguration;
@EnableGlobalMethodSecurity(
securedEnabled = true,
jsr250Enabled = true,
prePostEnabled = true
)
@Configuration
public class RoleConfig extends GlobalMethodSecurityConfiguration {
@Override
protected AccessDecisionManager accessDecisionManager() {
List<AccessDecisionVoter<?>> decisionVoters = new ArrayList<>();
ExpressionBasedPreInvocationAdvice expressionAdvice = new ExpressionBasedPreInvocationAdvice();
expressionAdvice.setExpressionHandler(getExpressionHandler());
decisionVoters.add(new PreInvocationAuthorizationAdviceVoter(expressionAdvice));
decisionVoters.add(new Jsr250Voter());
decisionVoters.add(new RoleVoter());
decisionVoters.add(roleHierarchyVoter());
decisionVoters.add(new AuthenticatedVoter());
return new AffirmativeBased(decisionVoters);
}
@Bean
public RoleHierarchyVoter roleHierarchyVoter() {
return new RoleHierarchyVoter(roleHierarchy());
}
@Bean
public RoleHierarchy roleHierarchy() {
RoleHierarchyImpl roleHierarchy = new RoleHierarchyImpl();
roleHierarchy.setHierarchy(UserGrade.getRoleHierarchy());
return roleHierarchy;
}
}

View File

@@ -1,13 +1,14 @@
package com.ticketing.server.global.security;
import com.ticketing.server.global.security.jwt.JwtFilter;
import com.ticketing.server.global.security.jwt.JwtSecurityConfig;
import com.ticketing.server.global.security.jwt.handle.JwtAccessDeniedHandler;
import com.ticketing.server.global.security.jwt.handle.JwtAuthenticationEntryPoint;
import com.ticketing.server.global.jwt.JwtFilter;
import com.ticketing.server.global.jwt.JwtSecurityConfig;
import com.ticketing.server.global.jwt.handle.JwtAccessDeniedHandler;
import com.ticketing.server.global.jwt.handle.JwtAuthenticationEntryPoint;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
@@ -17,6 +18,7 @@ import org.springframework.security.crypto.password.PasswordEncoder;
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(securedEnabled = true)
@RequiredArgsConstructor
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@@ -50,15 +52,12 @@ public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
.and()
.authorizeRequests()
.antMatchers(HttpMethod.POST, "/api/auth/token").permitAll()
.antMatchers(HttpMethod.POST, "/api/auth/refresh").permitAll()
.antMatchers(HttpMethod.POST, "/api/users").permitAll()
.antMatchers(HttpMethod.GET,"/api/movies").permitAll()
.antMatchers("/api/movieTimes/**").permitAll()
.antMatchers(HttpMethod.POST, "/user").permitAll()
.antMatchers(HttpMethod.POST, "/user/login").permitAll()
.antMatchers("/l7check").permitAll()
.antMatchers("/actuator/**").permitAll()
.antMatchers("/api/v3/", "/swagger-ui/**", "/swagger/", "/swagger-resources/**", "/v3/api-docs").permitAll()
.antMatchers("/actuator/health").permitAll()
.anyRequest().authenticated()
.and()
.apply(new JwtSecurityConfig(jwtFilter));
}

View File

@@ -1,26 +0,0 @@
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;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerExceptionResolver;
@Component("JwtAuthenticationEntryPoint")
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {
private final HandlerExceptionResolver resolver;
public JwtAuthenticationEntryPoint(@Qualifier("handlerExceptionResolver") HandlerExceptionResolver resolver) {
this.resolver = resolver;
}
@Override
public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException {
resolver.resolveException(request, response, null, authException);
}
}

View File

@@ -1,6 +1,5 @@
package com.ticketing.server.user.service;
package com.ticketing.server.global.service;
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,7 +20,7 @@ public class CustomUserDetailsService implements UserDetailsService {
public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
return userRepository.findByEmailAndIsDeletedFalse(email)
.map(this::createUserDetails)
.orElseThrow(ErrorCode::throwEmailNotFound);
.orElseThrow(() -> new UsernameNotFoundException("존재하지 않는 email 입니다. :: " + email));
}
private UserDetails createUserDetails(User user) {

View File

@@ -1,28 +0,0 @@
package com.ticketing.server.global.validator.constraints;
import com.ticketing.server.global.validator.constraintvalidators.FieldsValueNotMatchValidator;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import javax.validation.Constraint;
import javax.validation.Payload;
@Constraint(validatedBy = FieldsValueNotMatchValidator.class)
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FieldsValueNotMatch {
String message();
String field();
String fieldMatch();
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}

View File

@@ -1,29 +0,0 @@
package com.ticketing.server.global.validator.constraintvalidators;
import com.ticketing.server.global.validator.constraints.FieldsValueNotMatch;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import org.springframework.beans.BeanWrapperImpl;
public class FieldsValueNotMatchValidator implements ConstraintValidator<FieldsValueNotMatch, Object> {
private String field;
private String fieldMatch;
public void initialize(FieldsValueNotMatch constraintAnnotation) {
this.field = constraintAnnotation.field();
this.fieldMatch = constraintAnnotation.fieldMatch();
}
@Override
public boolean isValid(Object value, ConstraintValidatorContext context) {
Object fieldValue = new BeanWrapperImpl(value).getPropertyValue(field);
Object fieldMatchValue = new BeanWrapperImpl(value).getPropertyValue(fieldMatch);
if (fieldValue != null) {
return !fieldValue.equals(fieldMatchValue);
} else {
return fieldMatchValue != null;
}
}
}

View File

@@ -1,53 +1,8 @@
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;
@RestController
@RequestMapping("/api/movies")
@Api(value = "Movie API", tags = {"Movie"})
@RequiredArgsConstructor
@Slf4j
public class MovieController {
private final MovieService movieService;
@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()
)
);
}
}

View File

@@ -1,39 +0,0 @@
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)));
}
}

View File

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

View File

@@ -1,25 +0,0 @@
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);
}
}

View File

@@ -1,21 +0,0 @@
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)
public class MovieListResponse {
@ApiModelProperty(value = "영화 제목")
private List<MovieDTO> movieDtos;
public static MovieListResponse from(List<MovieDTO> movieDtos) {
return new MovieListResponse(movieDtos);
}
}

View File

@@ -1,21 +0,0 @@
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);
}
}

View File

@@ -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());
}
}

View File

@@ -14,11 +14,11 @@ import lombok.NoArgsConstructor;
@AllArgsConstructor
public class Movie extends AbstractEntity {
@NotNull
@Column(unique = true)
private String title;
@NotNull
@Column(unique = true)
private String title;
@NotNull
private Long runningTime;
@NotNull
private Integer runningTime;
}

View File

@@ -1,62 +0,0 @@
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.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.validation.constraints.NotNull;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Entity
@Getter
@NoArgsConstructor
public class MovieTime 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 Integer round;
@NotNull
private LocalDateTime startAt;
@NotNull
private LocalDateTime endAt;
@OneToMany(mappedBy = "movieTime", cascade = CascadeType.ALL)
private List<Ticket> tickets = new ArrayList<>();
private MovieTime(Movie movie, Theater theater, int round, LocalDateTime startAt, LocalDateTime endAt) {
this.movie = movie;
this.theater = theater;
this.round = round;
this.startAt = startAt;
this.endAt = endAt;
}
public static MovieTime of(Movie movie, Theater theater, int round, LocalDateTime startAt) {
Long runningTime = movie.getRunningTime();
LocalDateTime endAt = startAt.plusMinutes(runningTime);
return new MovieTime(movie, theater, round, startAt, endAt);
}
public List<Seat> getSeats() {
return this.theater.getSeats();
}
}

View File

@@ -0,0 +1,38 @@
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;
}

View File

@@ -6,11 +6,9 @@ import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.validation.constraints.NotNull;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Entity
@Getter
@NoArgsConstructor
public class Seat extends AbstractEntity {
@NotNull
@@ -18,20 +16,10 @@ public class Seat extends AbstractEntity {
@JoinColumn(name = "theater_id", referencedColumnName = "id", updatable = false)
private Theater theater;
@NotNull
private Integer seatRow;
@NotNull
private Integer seatColumn;
public Seat(Integer seatRow, Integer seatColumn, Theater theater) {
this.seatRow = seatRow;
this.seatColumn = seatColumn;
setTheater(theater);
}
@NotNull
private Integer seatRow;
private void setTheater(Theater theater) {
this.theater = theater;
theater.addSeat(this);
}
}

View File

@@ -1,32 +1,21 @@
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.Getter;
import lombok.NoArgsConstructor;
@Entity
@Getter
@NoArgsConstructor
@AllArgsConstructor
public class Theater extends AbstractEntity {
@NotNull
private Integer theaterNumber;
@OneToMany(mappedBy = "theater", cascade = CascadeType.ALL)
private List<Seat> seats = new ArrayList<>();
public Theater(Integer theaterNumber) {
this.theaterNumber = theaterNumber;
}
public void addSeat(Seat seat) {
seats.add(seat);
}
private Integer seatCount;
}

View File

@@ -1,18 +1,15 @@
package com.ticketing.server.movie.domain;
import com.ticketing.server.global.dto.repository.AbstractEntity;
import com.ticketing.server.payment.domain.Payment;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.validation.constraints.NotNull;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Entity
@Getter
@NoArgsConstructor
public class Ticket extends AbstractEntity {
@NotNull
@@ -23,26 +20,16 @@ public class Ticket extends AbstractEntity {
@NotNull
@ManyToOne
@JoinColumn(name = "movie_times_id", referencedColumnName = "id", updatable = false)
private MovieTime movieTime;
private MovieTimes movieTimes;
private Long paymentId;
@ManyToOne
@JoinColumn(name = "payment_id", referencedColumnName = "id", updatable = false)
private Payment payment;
@NotNull
@Enumerated(EnumType.STRING)
private TicketStatus status;
@NotNull
private Integer ticketPrice;
private Ticket(Seat seat, MovieTime movieTime, Integer ticketPrice) {
this.seat = seat;
this.movieTime = movieTime;
this.ticketPrice = ticketPrice;
this.status = TicketStatus.SALE;
}
public static Ticket of(Seat seat, MovieTime movieTime, Integer ticketPrice) {
return new Ticket(seat, movieTime, ticketPrice);
}
}

View File

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

View File

@@ -1,11 +1,8 @@
package com.ticketing.server.movie.domain.repository;
import com.ticketing.server.movie.domain.Movie;
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;
@Repository
@@ -13,9 +10,4 @@ public interface MovieRepository extends JpaRepository<Movie, Long> {
Optional<Movie> findByTitle(String title);
@Query(value = "SELECT * "
+ "FROM movie "
+ "WHERE deleted_at IS NULL", nativeQuery = true)
List<Movie> findValidMovies();
}

View File

@@ -1,21 +0,0 @@
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);
}

View File

@@ -0,0 +1,10 @@
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> {
}

View File

@@ -1,44 +1,9 @@
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.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;
import org.springframework.stereotype.Service;
@Service
@RequiredArgsConstructor
@Slf4j
public class MovieServiceImpl implements MovieService {
private final MovieRepository movieRepository;
@Override
public MovieDTO registerMovie(MovieRegisterDTO movieRegisterDto) {
Optional<Movie> movie = movieRepository.findByTitle(movieRegisterDto.getTitle());
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());
}
}

View File

@@ -1,43 +0,0 @@
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());
}
}

View File

@@ -0,0 +1,9 @@
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 {
}

View File

@@ -0,0 +1,9 @@
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 {
}

View File

@@ -1,18 +0,0 @@
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());
}
}

View File

@@ -1,24 +0,0 @@
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);
}
}

View File

@@ -1,28 +0,0 @@
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());
}
}

View File

@@ -1,13 +1,5 @@
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;
public interface MovieService {
MovieDTO registerMovie(MovieRegisterDTO movieRegisterDto);
List<MovieDTO> getMovies();
}

View File

@@ -1,11 +0,0 @@
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);
}

View File

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

View File

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

View File

@@ -1,20 +0,0 @@
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();
}
}

View File

@@ -1,102 +0,0 @@
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 java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
@RequiredArgsConstructor
public class
MovieSetupService {
private final MovieRepository movieRepository;
private final MovieTimeRepository movieTimeRepository;
private final TheaterRepository theaterRepository;
private final TicketRepository ticketRepository;
@Transactional
public void init() {
initMovie();
initTheater();
initMovieTime();
initTicket();
}
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 row = 1; row <= 2; row++) {
for (int col = 1; col <= 10; col++) {
new Seat(row, col, 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(MovieTime.of(movies.get(0), theater, 1, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 8, 0)));
movieTimes.add(MovieTime.of(movies.get(0), theater, 3, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 12, 0)));
movieTimes.add(MovieTime.of(movies.get(1), theater, 2, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 10, 0)));
movieTimes.add(MovieTime.of(movies.get(2), theater, 4, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 14, 0)));
movieTimes.add(MovieTime.of(movies.get(0), theater, 5, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 16, 0)));
movieTimes.add(MovieTime.of(movies.get(3), theater, 6, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 18, 0)));
movieTimes.add(MovieTime.of(movies.get(0), theater, 7, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 21, 0)));
movieTimes.add(MovieTime.of(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(Ticket.of(seat, movieTime, ticketPrice));
}
}
ticketRepository.saveAll(tickets);
}
}

View File

@@ -1,26 +1,23 @@
package com.ticketing.server.payment.domain;
import com.ticketing.server.global.dto.repository.AbstractEntity;
import com.ticketing.server.payment.service.dto.CreatePaymentDto;
import com.ticketing.server.user.domain.User;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.validation.constraints.NotEmpty;
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 Payment extends AbstractEntity {
@NotNull
private Long userId;
@NotEmpty
private String movieTitle;
@ManyToOne
@JoinColumn(name = "user_id", referencedColumnName = "id", updatable = false)
private User user;
@NotNull
@Enumerated(value = EnumType.STRING)
@@ -32,28 +29,10 @@ public class Payment extends AbstractEntity {
private String failedMessage;
@NotEmpty
@NotNull
private String paymentNumber;
@NotNull
private Integer totalPrice;
private Payment(Long userId, String movieTitle, PaymentType type, PaymentStatus status, String paymentNumber, Integer totalPrice) {
this.userId = userId;
this.movieTitle = movieTitle;
this.type = type;
this.status = status;
this.paymentNumber = paymentNumber;
this.totalPrice = totalPrice;
}
public static Payment from(CreatePaymentDto dto) {
return new Payment(dto.getUserId(),
dto.getMovieTitle(),
dto.getType(),
dto.getStatus(),
dto.getPaymentNumber(),
dto.getTotalPrice());
}
}

View File

@@ -1,12 +1,10 @@
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> findByUserId(Long userId);
}

View File

@@ -1,26 +1,9 @@
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.interfaces.PaymentService;
import com.ticketing.server.user.api.dto.response.SimplePaymentsResponse;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
@Service
@RequiredArgsConstructor
public class PaymentServiceImpl implements PaymentService {
private final PaymentRepository paymentRepository;
@Override
public SimplePaymentsResponse findSimplePayments(Long userId) {
return paymentRepository.findByUserId(userId)
.stream()
.map(SimplePaymentDto::from)
.collect(Collectors.collectingAndThen(Collectors.toList()
, list -> SimplePaymentsResponse.from(userId, list)));
}
}

View File

@@ -1,30 +0,0 @@
package com.ticketing.server.payment.service.dto;
import com.ticketing.server.payment.domain.PaymentStatus;
import com.ticketing.server.payment.domain.PaymentType;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class CreatePaymentDto {
private Long userId;
private String movieTitle;
private PaymentType type;
private PaymentStatus status;
private String paymentNumber;
private Integer totalPrice;
public static CreatePaymentDto of(
Long userId,
String movieTitle,
PaymentType type,
PaymentStatus status,
String paymentNumber,
Integer totalPrice) {
return new CreatePaymentDto(userId, movieTitle, type, status, paymentNumber, totalPrice);
}
}

View File

@@ -1,25 +0,0 @@
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 Long paymentId;
private String movieTitle;
private String paymentNumber;
private Integer totalPrice;
public static SimplePaymentDto from(Payment payment) {
return new SimplePaymentDto(
payment.getId(),
payment.getMovieTitle(),
payment.getPaymentNumber(),
payment.getTotalPrice()
);
}
}

View File

@@ -1,9 +1,5 @@
package com.ticketing.server.payment.service.interfaces;
import com.ticketing.server.user.api.dto.response.SimplePaymentsResponse;
public interface PaymentService {
SimplePaymentsResponse findSimplePayments(Long userId);
}

View File

@@ -1,10 +0,0 @@
package com.ticketing.server.user.api;
import com.ticketing.server.user.api.dto.request.SimplePaymentsRequest;
import com.ticketing.server.user.api.dto.response.SimplePaymentsResponse;
public interface PaymentClient {
SimplePaymentsResponse getSimplePayments(SimplePaymentsRequest request);
}

View File

@@ -1,18 +0,0 @@
package com.ticketing.server.user.api.dto.request;
import com.ticketing.server.user.domain.User;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class SimplePaymentsRequest {
private Long userId;
public static SimplePaymentsRequest from(User user) {
return new SimplePaymentsRequest(user.getId());
}
}

View File

@@ -1,21 +0,0 @@
package com.ticketing.server.user.api.dto.response;
import com.ticketing.server.payment.service.dto.SimplePaymentDto;
import java.util.List;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class SimplePaymentsResponse {
private Long userId;
private List<SimplePaymentDto> payments;
public static SimplePaymentsResponse from(Long userId, List<SimplePaymentDto> simplePayments) {
return new SimplePaymentsResponse(userId, simplePayments);
}
}

View File

@@ -1,21 +0,0 @@
package com.ticketing.server.user.api.impl;
import com.ticketing.server.payment.service.PaymentServiceImpl;
import com.ticketing.server.user.api.PaymentClient;
import com.ticketing.server.user.api.dto.request.SimplePaymentsRequest;
import com.ticketing.server.user.api.dto.response.SimplePaymentsResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
@Service
@RequiredArgsConstructor
public class PaymentClientImpl implements PaymentClient {
private final PaymentServiceImpl paymentService;
@Override
public SimplePaymentsResponse getSimplePayments(SimplePaymentsRequest request) {
return paymentService.findSimplePayments(request.getUserId());
}
}

View File

@@ -1,63 +0,0 @@
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.interfaces.AuthenticationService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/auth")
@Slf4j
public class AuthController {
private final AuthenticationService authenticationService;
@PostMapping("/token")
public ResponseEntity<TokenDto> login(@RequestBody LoginRequest loginRequest) {
TokenDto tokenDto = authenticationService.generateTokenDto(loginRequest.toAuthentication());
return ResponseEntity.status(HttpStatus.OK)
.headers(getHttpHeaders())
.body(tokenDto);
}
@PostMapping("/refresh")
public ResponseEntity<TokenDto> refreshToken(@RequestParam("refreshToken") String refreshToken) {
TokenDto tokenDto = authenticationService.reissueTokenDto(refreshToken);
return ResponseEntity.status(HttpStatus.OK)
.headers(getHttpHeaders())
.body(tokenDto);
}
@PostMapping("/logout")
public ResponseEntity<LogoutResponse> logout(@AuthenticationPrincipal UserDetails userRequest) {
LogoutResponse logoutResponse = authenticationService.deleteRefreshToken(userRequest.getUsername());
return ResponseEntity.status(HttpStatus.OK)
.body(logoutResponse);
}
private HttpHeaders getHttpHeaders() {
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.set(HttpHeaders.CACHE_CONTROL, "no-cache, no-store, must-revalidate");
httpHeaders.set(HttpHeaders.PRAGMA, "no-store");
httpHeaders.set(HttpHeaders.EXPIRES, "0");
return httpHeaders;
}
}

View File

@@ -1,76 +1,73 @@
package com.ticketing.server.user.application;
import com.ticketing.server.global.jwt.JwtProperties;
import com.ticketing.server.user.application.request.LoginRequest;
import com.ticketing.server.user.application.request.SignUpRequest;
import com.ticketing.server.user.application.request.UserChangePasswordRequest;
import com.ticketing.server.user.application.request.UserDeleteRequest;
import com.ticketing.server.user.application.request.UserModifyPasswordRequest;
import com.ticketing.server.user.application.response.LoginResponse;
import com.ticketing.server.user.application.response.SignUpResponse;
import com.ticketing.server.user.application.response.SimplePaymentDetailsResponse;
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 javax.servlet.http.HttpServletResponse;
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.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PatchMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/users")
@RequestMapping("/api/user")
@Slf4j
public class UserController {
private final UserServiceImpl userService;
private final PasswordEncoder passwordEncoder;
private final JwtProperties jwtProperties;
@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));
}
@GetMapping("/details")
@Secured("ROLE_GUEST")
public ResponseEntity<UserDetailResponse> details(@AuthenticationPrincipal UserDetails userRequest) {
User user = userService.findByEmail(userRequest.getUsername());
return ResponseEntity.status(HttpStatus.OK).body(UserDetailResponse.from(user));
return ResponseEntity.status(HttpStatus.CREATED).body(SignUpResponse.of(user));
}
@DeleteMapping
@Secured(UserGrade.ROLES.GUEST)
@Secured("ROLE_GUEST")
public ResponseEntity<UserDeleteResponse> deleteUser(@RequestBody @Valid UserDeleteRequest request) {
User user = userService.delete(request.toDeleteUserDto(passwordEncoder));
return ResponseEntity.status(HttpStatus.OK).body(UserDeleteResponse.from(user));
return ResponseEntity.status(HttpStatus.OK).body(UserDeleteResponse.of(user));
}
@PutMapping("/password")
@Secured(UserGrade.ROLES.GUEST)
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));
}
@GetMapping("/payments")
@PatchMapping("/password")
@Secured("ROLE_GUEST")
public ResponseEntity<SimplePaymentDetailsResponse> getPayments(@AuthenticationPrincipal UserDetails userRequest) {
SimplePaymentDetailsResponse paymentDetails = userService.findSimplePaymentDetails(userRequest.getUsername());
return ResponseEntity.status(HttpStatus.OK).body(paymentDetails);
public ResponseEntity<UserChangePasswordResponse> changePassword(@RequestBody @Valid UserModifyPasswordRequest request) {
if (request.oldEqualNew()) {
log.error("기존 패스워드와 동일한 패스워드로 변경할 수 없습니다.");
return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
}
User user = userService.changePassword(request.toChangePasswordDto(passwordEncoder));
return ResponseEntity.status(HttpStatus.OK).body(UserChangePasswordResponse.of(user));
}
@PostMapping("/login")
public ResponseEntity<LoginResponse> login(@RequestBody LoginRequest loginRequest, HttpServletResponse response) {
String accessToken = userService.login(loginRequest.toAuthentication());
response.setHeader(jwtProperties.getAccessHeader(), accessToken);
return ResponseEntity.status(HttpStatus.OK).body(LoginResponse.of(accessToken));
}
}

View File

@@ -1,7 +1,7 @@
package com.ticketing.server.user.application.request;
import com.ticketing.server.global.validator.constraints.FieldsValueNotMatch;
import com.ticketing.server.user.service.dto.ChangePasswordDTO;
import javax.validation.constraints.Email;
import javax.validation.constraints.NotEmpty;
import lombok.AllArgsConstructor;
import lombok.Getter;
@@ -11,12 +11,11 @@ import org.springframework.security.crypto.password.PasswordEncoder;
@Getter
@NoArgsConstructor
@AllArgsConstructor
@FieldsValueNotMatch(
field = "oldPassword",
fieldMatch = "newPassword",
message = "{validation.password.not.change}"
)
public class UserChangePasswordRequest {
public class UserModifyPasswordRequest {
@NotEmpty(message = "{validation.not.empty.email}")
@Email(message = "{validation.email}")
private String email;
@NotEmpty(message = "{validation.not.empty.oldpassword}")
private String oldPassword;
@@ -24,8 +23,12 @@ public class UserChangePasswordRequest {
@NotEmpty(message = "{validation.not.empty.newpassword}")
private String newPassword;
public ChangePasswordDTO toChangePasswordDto(String email, PasswordEncoder passwordEncoder) {
public ChangePasswordDTO toChangePasswordDto(PasswordEncoder passwordEncoder) {
return new ChangePasswordDTO(email, oldPassword, newPassword, passwordEncoder);
}
public boolean oldEqualNew() {
return oldPassword.equals(newPassword);
}
}

View File

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

View File

@@ -1,28 +0,0 @@
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)
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());
}
}

View File

@@ -13,7 +13,7 @@ public class SignUpResponse {
private String email;
public static SignUpResponse from(User user) {
public static SignUpResponse of(User user) {
return new SignUpResponse(user.getName(), user.getEmail());
}

View File

@@ -1,21 +0,0 @@
package com.ticketing.server.user.application.response;
import com.ticketing.server.payment.service.dto.SimplePaymentDto;
import com.ticketing.server.user.api.dto.response.SimplePaymentsResponse;
import java.util.List;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class SimplePaymentDetailsResponse {
private String email;
private List<SimplePaymentDto> payments;
public static SimplePaymentDetailsResponse of(String email, SimplePaymentsResponse paymentsResponse) {
return new SimplePaymentDetailsResponse(email, paymentsResponse.getPayments());
}
}

View File

@@ -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);
}
}

View File

@@ -13,7 +13,7 @@ public class UserChangePasswordResponse {
private String email;
public static UserChangePasswordResponse from(User user) {
public static UserChangePasswordResponse of(User user) {
return new UserChangePasswordResponse(user.getName(), user.getEmail());
}

View File

@@ -13,7 +13,7 @@ public class UserDeleteResponse {
private String email;
public static UserDeleteResponse from(User user) {
public static UserDeleteResponse of(User user) {
return new UserDeleteResponse(user.getName(), user.getEmail());
}

View File

@@ -1,21 +0,0 @@
package com.ticketing.server.user.application.response;
import com.ticketing.server.user.domain.User;
import com.ticketing.server.user.domain.UserGrade;
import lombok.AllArgsConstructor;
import lombok.Getter;
@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());
}
}

View File

@@ -1,7 +1,8 @@
package com.ticketing.server.user.domain;
import com.ticketing.server.global.dto.repository.AbstractEntity;
import com.ticketing.server.global.exception.ErrorCode;
import com.ticketing.server.global.exception.AlreadyDeletedException;
import com.ticketing.server.global.exception.PasswordMismatchException;
import com.ticketing.server.global.validator.constraints.Phone;
import com.ticketing.server.user.service.dto.ChangePasswordDTO;
import com.ticketing.server.user.service.dto.DeleteUserDTO;
@@ -22,6 +23,14 @@ import lombok.NoArgsConstructor;
@NoArgsConstructor
public class User extends AbstractEntity {
public User(String name, String email, String password, UserGrade grade, String phone) {
this.name = name;
this.email = email;
this.password = password;
this.grade = grade;
this.phone = phone;
}
@Column(name = "name")
@NotEmpty(message = "{validation.not.empty.name}")
private String name;
@@ -49,17 +58,9 @@ public class User extends AbstractEntity {
private LocalDateTime deletedAt;
public User(String name, String email, String password, UserGrade grade, String phone) {
this.name = name;
this.email = email;
this.password = password;
this.grade = grade;
this.phone = phone;
}
public User delete(DeleteUserDTO deleteUser) {
if (isDeleted) {
throw ErrorCode.throwDeletedEmail();
throw new AlreadyDeletedException("이미 탈퇴된 회원 입니다.");
}
checkPassword(deleteUser);
@@ -78,7 +79,7 @@ public class User extends AbstractEntity {
public void checkPassword(PasswordMatches passwordMatches) {
if (!passwordMatches.passwordMatches(password)) {
throw ErrorCode.throwMismatchPassword();
throw new PasswordMismatchException();
}
}

View File

@@ -1,38 +1,5 @@
package com.ticketing.server.user.domain;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
public enum UserGrade {
ADMIN(ROLES.ADMIN, null),
STAFF(ROLES.STAFF, ROLES.ADMIN),
GUEST(ROLES.GUEST, ROLES.STAFF);
private final String roleName;
private final String parentName;
public static class ROLES {
public static final String ADMIN = "ROLE_ADMIN";
public static final String STAFF = "ROLE_STAFF";
public static final String GUEST = "ROLE_GUEST";
private ROLES() {
}
}
public static String getRoleHierarchy() {
StringBuilder sb = new StringBuilder();
for (UserGrade grade : UserGrade.values()) {
if (grade.parentName != null) {
sb.append(grade.parentName);
sb.append(" > ");
sb.append(grade.roleName);
sb.append("\n");
}
}
return sb.toString();
}
GUEST, STAFF
}

View File

@@ -1,96 +0,0 @@
package com.ticketing.server.user.service;
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.interfaces.AuthenticationService;
import lombok.RequiredArgsConstructor;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
@Service
@RequiredArgsConstructor
public class AuthenticationServiceImpl implements AuthenticationService {
private final RefreshRedisRepository refreshRedisRepository;
private final JwtProvider jwtProvider;
private final JwtProperties jwtProperties;
private final AuthenticationManagerBuilder authenticationManagerBuilder;
@Override
@Transactional
public TokenDto generateTokenDto(UsernamePasswordAuthenticationToken authenticationToken) {
// 회원인증
Authentication authentication = authenticationManagerBuilder.getObject().authenticate(authenticationToken);
String email = authenticationToken.getName();
// 토큰 발급
TokenDto tokenDto = jwtProvider.generateTokenDto(authentication);
// refresh 토큰이 있으면 수정, 없으면 생성
refreshRedisRepository.findByEmail(email)
.ifPresentOrElse(
tokenEntity -> tokenEntity.changeToken(tokenDto.getRefreshToken()),
() -> refreshRedisRepository.save(new RefreshToken(email, tokenDto.getRefreshToken()))
);
return tokenDto;
}
@Override
@Transactional
public TokenDto reissueTokenDto(String bearerRefreshToken) {
String refreshToken = resolveToken(bearerRefreshToken);
// 토큰 검증
jwtProvider.validateToken(refreshToken);
Authentication authentication = jwtProvider.getAuthentication(refreshToken);
// Redis 에 토큰이 있는지 검증
RefreshToken findTokenEntity = refreshRedisRepository.findByEmail(authentication.getName())
.orElseThrow(ErrorCode::throwRefreshTokenNotFound);
// redis 토큰과 input 토큰이 일치한지 확인
if (!refreshToken.equals(findTokenEntity.getToken())) {
throw ErrorCode.throwUnavailableRefreshToken();
}
// 토큰 발급
TokenDto tokenDto = jwtProvider.generateTokenDto(authentication);
// 토큰 최신화
findTokenEntity.changeToken(tokenDto.getRefreshToken());
refreshRedisRepository.save(findTokenEntity);
return tokenDto;
}
@Override
@Transactional
public LogoutResponse deleteRefreshToken(String email) {
return refreshRedisRepository.findByEmail(email)
.map(tokenDto -> {
refreshRedisRepository.delete(tokenDto);
return LogoutResponse.from(tokenDto);
}).orElseGet(() -> LogoutResponse.from(email));
}
private String resolveToken(String bearerToken) {
if (StringUtils.hasText(bearerToken) && jwtProperties.hasTokenStartsWith(bearerToken)) {
return bearerToken.substring(7);
}
throw ErrorCode.throwTokenType();
}
}

View File

@@ -1,10 +1,7 @@
package com.ticketing.server.user.service;
import com.ticketing.server.global.exception.ErrorCode;
import com.ticketing.server.user.api.PaymentClient;
import com.ticketing.server.user.api.dto.request.SimplePaymentsRequest;
import com.ticketing.server.user.api.dto.response.SimplePaymentsResponse;
import com.ticketing.server.user.application.response.SimplePaymentDetailsResponse;
import com.ticketing.server.global.exception.NotFoundEmailException;
import com.ticketing.server.global.jwt.JwtProvider;
import com.ticketing.server.user.domain.User;
import com.ticketing.server.user.domain.repository.UserRepository;
import com.ticketing.server.user.service.dto.ChangePasswordDTO;
@@ -15,6 +12,9 @@ import java.util.Optional;
import javax.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
@@ -27,23 +27,37 @@ import org.springframework.validation.annotation.Validated;
public class UserServiceImpl implements UserService {
private final UserRepository userRepository;
private final PaymentClient paymentClient;
private final AuthenticationManagerBuilder authenticationManagerBuilder;
private final JwtProvider jwtProvider;
@Override
public String login(UsernamePasswordAuthenticationToken authenticationToken) {
Authentication authentication = authenticationManagerBuilder.getObject().authenticate(authenticationToken);
return jwtProvider.createToken(authentication);
}
@Override
@Transactional
public User register(@Valid SignUpDTO signUpDto) {
Optional<User> user = userRepository.findByEmail(signUpDto.getEmail());
if (user.isEmpty()) {
return userRepository.save(signUpDto.toUser());
if (user.isPresent()) {
log.error("이미 존재하는 이메일이기 때문에 신규 회원가입을 진행할 수 없습니다. :: {}", signUpDto);
throw new IllegalArgumentException("이미 존재하는 이메일이기 때문에 신규 회원가입을 진행할 수 없습니다.");
}
throw ErrorCode.throwDuplicateEmail();
return userRepository.save(signUpDto.toUser());
}
@Override
@Transactional
public User delete(@Valid DeleteUserDTO deleteUserDto) {
User user = findNotDeletedUserByEmail(deleteUserDto.getEmail());
User user = userRepository.findByEmail(deleteUserDto.getEmail())
.orElseThrow(() -> {
log.error("존재하지 않는 이메일 입니다. :: {}", deleteUserDto.getEmail());
throw new NotFoundEmailException();
}
);
return user.delete(deleteUserDto);
}
@@ -54,23 +68,12 @@ public class UserServiceImpl implements UserService {
return user.changePassword(changePasswordDto);
}
@Override
public User findByEmail(String email) {
return userRepository.findByEmail(email)
.orElseThrow(ErrorCode::throwEmailNotFound);
}
@Override
public SimplePaymentDetailsResponse findSimplePaymentDetails(String email) {
User user = findNotDeletedUserByEmail(email);
SimplePaymentsResponse simplePayments = paymentClient.getSimplePayments(SimplePaymentsRequest.from(user));
return SimplePaymentDetailsResponse.of(email, simplePayments);
}
private User findNotDeletedUserByEmail(String email) {
return userRepository.findByEmailAndIsDeletedFalse(email)
.orElseThrow(ErrorCode::throwEmailNotFound);
.orElseThrow(() -> {
log.error("존재하지 않는 이메일 입니다. :: {}", email);
throw new NotFoundEmailException();
});
}
}

View File

@@ -6,6 +6,13 @@ import org.springframework.security.crypto.password.PasswordEncoder;
public class ChangePasswordDTO implements PasswordMatches {
public ChangePasswordDTO(String email, String oldPassword, String newPassword, PasswordEncoder passwordEncoder) {
this.email = email;
this.oldPassword = oldPassword;
this.newPassword = newPassword;
this.passwordEncoder = passwordEncoder;
}
@NotEmpty(message = "{validation.not.empty.email}")
@Email(message = "{validation.email}")
private String email;
@@ -18,13 +25,6 @@ public class ChangePasswordDTO implements PasswordMatches {
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;
}
public String getEmail() {
return email;
}

View File

@@ -6,6 +6,12 @@ import org.springframework.security.crypto.password.PasswordEncoder;
public class DeleteUserDTO implements PasswordMatches {
public DeleteUserDTO(String email, String inputPassword, PasswordEncoder passwordEncoder) {
this.email = email;
this.inputPassword = inputPassword;
this.passwordEncoder = passwordEncoder;
}
@NotEmpty(message = "{validation.not.empty.email}")
@Email(message = "{validation.email}")
private String email;
@@ -15,12 +21,6 @@ public class DeleteUserDTO implements PasswordMatches {
private PasswordEncoder passwordEncoder;
public DeleteUserDTO(String email, String inputPassword, PasswordEncoder passwordEncoder) {
this.email = email;
this.inputPassword = inputPassword;
this.passwordEncoder = passwordEncoder;
}
@Override
public boolean passwordMatches(String password) {
return passwordEncoder.matches(this.inputPassword, password);

View File

@@ -1,15 +0,0 @@
package com.ticketing.server.user.service.interfaces;
import com.ticketing.server.user.application.response.LogoutResponse;
import com.ticketing.server.user.application.response.TokenDto;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
public interface AuthenticationService {
TokenDto generateTokenDto(UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken);
TokenDto reissueTokenDto(String bearerRefreshToken);
LogoutResponse deleteRefreshToken(String email);
}

View File

@@ -1,22 +1,21 @@
package com.ticketing.server.user.service.interfaces;
import com.ticketing.server.user.application.response.SimplePaymentDetailsResponse;
import com.ticketing.server.user.domain.User;
import com.ticketing.server.user.service.dto.ChangePasswordDTO;
import com.ticketing.server.user.service.dto.DeleteUserDTO;
import com.ticketing.server.user.service.dto.SignUpDTO;
import javax.validation.Valid;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
public interface UserService {
String login(UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken);
User register(@Valid SignUpDTO signUpDto);
User delete(@Valid DeleteUserDTO deleteUserDto);
User changePassword(@Valid ChangePasswordDTO changePasswordDto);
User findByEmail(String email);
SimplePaymentDetailsResponse findSimplePaymentDetails(String email);
}

View File

@@ -11,4 +11,4 @@ spring:
show_sql: true
format_sql: true
hibernate:
ddl-auto: create
ddl-auto: update

View File

@@ -4,9 +4,6 @@ server:
spring:
profiles:
active: local
redis:
host: localhost
port: 6379
jpa:
hibernate:
@@ -18,24 +15,12 @@ spring:
maximum-pool-size: 10 # default 10
max-lifetime: 1800000 # default 30 minutes
mvc:
pathmatch:
matching-strategy: ant_path_matcher
throw-exception-if-no-handler-found: true
jasypt:
encryptor:
bean: jasyptStringEncryptor
jwt:
access-header: Authorization
refresh-header: REFRESH_TOKEN
access-header: ACCESS_TOKEN
prefix: Bearer
secret-key: Zi1sYWItdGlja2V0aW5nLXByb2plY3Qtc3ByaW5nLWJvb3Qtc2VjdXJpdHktand0LXNlY3JldC1rZXktZi1sYWItdGlja2V0aW5nLXByb2plY3Qtc3ByaW5nLWJvb3Qtc2VjdXJpdHktand0LXNlY3JldC1rZXkK
access-token-validity-in-seconds: 60 # 1분
refresh-token-validity-in-seconds: 259200 # 3일
springfox:
documentation:
swagger:
use-model-v3: false
token-validity-in-seconds: 86400

View File

@@ -1,10 +1,9 @@
validation.not.empty.name=\uC774\uB984\uC740 \uD544\uC218 \uC785\uB2C8\uB2E4.
validation.not.empty.email=\uC774\uBA54\uC77C\uC740 \uD544\uC218 \uC785\uB2C8\uB2E4.
validation.not.empty.password=\uD328\uC2A4\uC6CC\uB4DC\uB294 \uD544\uC218 \uC785\uB2C8\uB2E4.
validation.not.empty.oldpassword=\uD604\uC7AC \uD328\uC2A4\uC6CC\uB4DC\uB294 \uD544\uC218 \uC785\uB2C8\uB2E4.
validation.not.empty.newpassword=\uBCC0\uACBD\uD560 \uD328\uC2A4\uC6CC\uB4DC\uB294 \uD544\uC218 \uC785\uB2C8\uB2E4.
validation.not.empty.grade=\uC0AC\uC6A9\uC790 \uB4F1\uAE09\uC740 \uD544\uC218 \uC785\uB2C8\uB2E4.
validation.not.empty.phone=\uD734\uB300\uBC88\uD638\uB294 \uD544\uC218 \uC785\uB2C8\uB2E4.
validation.email=\uC774\uBA54\uC77C\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.
validation.phone=\uD734\uB300\uBC88\uD638\uAC00 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.
validation.password.not.change=\uB3D9\uC77C\uD55C \uD328\uC2A4\uC6CC\uB4DC\uB85C \uBCC0\uACBD\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.
validation.not.empty.name="\uC774\uB984\uC740 \uD544\uC218 \uC785\uB2C8\uB2E4."
validation.not.empty.email="\uC774\uBA54\uC77C\uC740 \uD544\uC218 \uC785\uB2C8\uB2E4."
validation.not.empty.password="\uD328\uC2A4\uC6CC\uB4DC\uB294 \uD544\uC218 \uC785\uB2C8\uB2E4."
validation.not.empty.oldpassword="\uD604\uC7AC \uD328\uC2A4\uC6CC\uB4DC\uB294 \uD544\uC218 \uC785\uB2C8\uB2E4."
validation.not.empty.newpassword="\uBCC0\uACBD\uD560 \uD328\uC2A4\uC6CC\uB4DC\uB294 \uD544\uC218 \uC785\uB2C8\uB2E4."
validation.not.empty.grade="\uC0AC\uC6A9\uC790 \uB4F1\uAE09\uC740 \uD544\uC218 \uC785\uB2C8\uB2E4."
validation.not.empty.phone="\uD734\uB300\uBC88\uD638\uB294 \uD544\uC218 \uC785\uB2C8\uB2E4."
validation.email="\uC774\uBA54\uC77C\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4."
validation.phone="\uD734\uB300\uBC88\uD638\uAC00 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4."

View File

@@ -1,10 +1,9 @@
validation.not.empty.name=name is required.
validation.not.empty.email=email is required.
validation.not.empty.password=password is required.
validation.not.empty.oldpassword=Old Password is required.
validation.not.empty.newpassword=New Password is required.
validation.not.empty.grade=user grade is required.
validation.not.empty.phone=phone is required.
validation.email=email is not valid.
validation.phone=phone is not valid.
validation.password.not.change=password not change.
validation.not.empty.name="name is required."
validation.not.empty.email="email is required."
validation.not.empty.password="password is required."
validation.not.empty.oldpassword="Old Password is required."
validation.not.empty.newpassword="New Password is required."
validation.not.empty.grade="user grade is required."
validation.not.empty.phone="phone is required."
validation.email="email is not valid."
validation.phone="phone is not valid."

View File

@@ -1,10 +1,9 @@
validation.not.empty.name=\uC774\uB984\uC740 \uD544\uC218 \uC785\uB2C8\uB2E4.
validation.not.empty.email=\uC774\uBA54\uC77C\uC740 \uD544\uC218 \uC785\uB2C8\uB2E4.
validation.not.empty.password=\uD328\uC2A4\uC6CC\uB4DC\uB294 \uD544\uC218 \uC785\uB2C8\uB2E4.
validation.not.empty.oldpassword=\uD604\uC7AC \uD328\uC2A4\uC6CC\uB4DC\uB294 \uD544\uC218 \uC785\uB2C8\uB2E4.
validation.not.empty.newpassword=\uBCC0\uACBD\uD560 \uD328\uC2A4\uC6CC\uB4DC\uB294 \uD544\uC218 \uC785\uB2C8\uB2E4.
validation.not.empty.grade=\uC0AC\uC6A9\uC790 \uB4F1\uAE09\uC740 \uD544\uC218 \uC785\uB2C8\uB2E4.
validation.not.empty.phone=\uD734\uB300\uBC88\uD638\uB294 \uD544\uC218 \uC785\uB2C8\uB2E4.
validation.email=\uC774\uBA54\uC77C\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.
validation.phone=\uD734\uB300\uBC88\uD638\uAC00 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.
validation.password.not.change=\uB3D9\uC77C\uD55C \uD328\uC2A4\uC6CC\uB4DC\uB85C \uBCC0\uACBD\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.
validation.not.empty.name="\uC774\uB984\uC740 \uD544\uC218 \uC785\uB2C8\uB2E4."
validation.not.empty.email="\uC774\uBA54\uC77C\uC740 \uD544\uC218 \uC785\uB2C8\uB2E4."
validation.not.empty.password="\uD328\uC2A4\uC6CC\uB4DC\uB294 \uD544\uC218 \uC785\uB2C8\uB2E4."
validation.not.empty.oldpassword="\uD604\uC7AC \uD328\uC2A4\uC6CC\uB4DC\uB294 \uD544\uC218 \uC785\uB2C8\uB2E4."
validation.not.empty.newpassword="\uBCC0\uACBD\uD560 \uD328\uC2A4\uC6CC\uB4DC\uB294 \uD544\uC218 \uC785\uB2C8\uB2E4."
validation.not.empty.grade="\uC0AC\uC6A9\uC790 \uB4F1\uAE09\uC740 \uD544\uC218 \uC785\uB2C8\uB2E4."
validation.not.empty.phone="\uD734\uB300\uBC88\uD638\uB294 \uD544\uC218 \uC785\uB2C8\uB2E4."
validation.email="\uC774\uBA54\uC77C\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4."
validation.phone="\uD734\uB300\uBC88\uD638\uAC00 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4."

View File

@@ -0,0 +1,13 @@
package com.ticketing.server;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class ServerApplicationTests {
@Test
void contextLoads() {
}
}

View File

@@ -1,4 +1,4 @@
package com.ticketing.server.global.security.jwt;
package com.ticketing.server.global.jwt;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertAll;
@@ -27,38 +27,10 @@ class JwtPropertiesTest {
// when
// then
assertAll(
() -> assertThat(jwtProperties.getAccessHeader()).isEqualTo("Authorization")
, () -> assertThat(jwtProperties.getRefreshHeader()).isEqualTo("REFRESH_TOKEN")
() -> assertThat(jwtProperties.getAccessHeader()).isEqualTo("ACCESS_TOKEN")
, () -> assertThat(jwtProperties.getPrefix()).isEqualTo("Bearer")
, () -> assertThat(jwtProperties.getAccessTokenValidityInSeconds()).isEqualTo(60)
, () -> assertThat(jwtProperties.getRefreshTokenValidityInSeconds()).isEqualTo(259200)
, () -> assertThat(jwtProperties.getTokenValidityInSeconds()).isEqualTo(86400)
, () -> assertThat(jwtProperties.getSecretKey()).isNotEmpty());
}
@Test
@DisplayName("token prefix 가 일치할 경우")
void hasTokenStartsWithTrue() {
// given
String token = jwtProperties.getPrefix() + " " + "tokenPrefixTest";
// when
boolean result = jwtProperties.hasTokenStartsWith(token);
// then
assertThat(result).isTrue();
}
@Test
@DisplayName("token prefix 가 일치하지 않을 경우")
void hasTokenStartsWithFalse() {
// given
String token = "tokenPrefixTest";
// when
boolean result = jwtProperties.hasTokenStartsWith(token);
// then
assertThat(result).isFalse();
}
}

View File

@@ -1,9 +1,8 @@
package com.ticketing.server.global.security.jwt;
package com.ticketing.server.global.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.domain.UserGrade;
import java.util.Collections;
import org.junit.jupiter.api.BeforeEach;
@@ -26,12 +25,12 @@ class TokenProviderTest {
@Autowired
private JwtProperties jwtProperties;
JwtProvider jwtProvider;
JwtProvider tokenProvider;
@BeforeEach
void init() {
jwtProvider = new JwtProvider(jwtProperties);
tokenProvider = new JwtProvider(jwtProperties);
}
@Test
@@ -43,10 +42,10 @@ class TokenProviderTest {
new UsernamePasswordAuthenticationToken("ticketing@gmail.com", "123456", Collections.singleton(grantedAuthority));
// when
TokenDto tokenDto = jwtProvider.generateTokenDto(authenticationToken);
String token = tokenProvider.createToken(authenticationToken);
// then
assertThat(tokenDto).isInstanceOf(TokenDto.class);
assertThat(token).isNotEmpty();
}
@Test
@@ -58,8 +57,8 @@ class TokenProviderTest {
new UsernamePasswordAuthenticationToken("ticketing@gmail.com", "123456", Collections.singleton(grantedAuthority));
// when
TokenDto tokenDto = jwtProvider.generateTokenDto(authenticationToken);
Authentication authentication = jwtProvider.getAuthentication(tokenDto.getAccessToken());
String token = tokenProvider.createToken(authenticationToken);
Authentication authentication = tokenProvider.getAuthentication(token);
// then
assertThat(authentication.getName()).isEqualTo("ticketing@gmail.com");

Some files were not shown because too many files have changed in this diff Show More