Compare commits

..

2 Commits

Author SHA1 Message Date
dongHyo
e7fabb7c03 refactor: 생성자 메서드 위치 변경 2022-06-17 23:43:38 +09:00
dongHyo
7af5249116 feat: 계층권한 구현 2022-06-17 23:42:26 +09:00
216 changed files with 664 additions and 6774 deletions

View File

@@ -1,5 +1,5 @@
# 🍿 Ticketing
영화 예매 사이트를 대용량 트래픽에 대응할 수 있도록 설계.
영화 예매 서비스
<br/>
@@ -8,59 +8,32 @@
- 기획 및 설계 : 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)
- [Issue Posting](https://github.com/f-lab-edu/Ticketing/wiki/Issue-Posting)
<br/>
<br/><br/>
## 🧩 ERD
``` mermaid
erDiagram
MOVIE ||--o{ MOVIE_TIME : ""
MOVIE ||--o{ MOVIE_TIMES : ""
MOVIE {
bigint id PK "영화 ID"
varchar title "영화제목"
int running_time "러닝타임"
datetime deleted_at "삭제일시"
datetime created_at "등록일시"
datetime updated_at "수정일시"
}
THEATER ||--o{ MOVIE_TIME : ""
THEATER ||--o{ MOVIE_TIMES : ""
THEATER ||--|{ SEAT : ""
THEATER {
bigint id PK "상영관 ID"
int theater_number "상영관 번호"
int seat_count "좌석수"
datetime deleted_at "삭제일시"
datetime created_at "등록일시"
datetime updated_at "수정일시"
}
@@ -70,59 +43,56 @@ erDiagram
bigint theater_id FK "상영관 ID"
int column "열"
int row "행"
datetime deleted_at "삭제일시"
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 "종료 시간"
datetime deleted_at "삭제일시"
datetime created_at "등록일시"
datetime updated_at "수정일시"
}
TICKET {
bigint id PK "티켓 ID"
bigint seat_id FK "좌석 ID"
bigint movie_time_id FK "상영시간표 ID"
bigint payment_id "결제 ID"
varchar status "상태 - 매가능/예약/"
bigint movie_times_id FK "상영시간표 ID"
bigint payment_id FK "결제 ID"
varchar status "상태 - 매가능/예약진행중/판매완료"
int ticket_price "가격"
datetime deleted_at "삭제일시"
datetime created_at "등록일시"
datetime updated_at "수정일시"
}
TICKET }|--|| PAYMENT : ""
PAYMENT {
bigint id PK "결제 ID"
bigint user_alternate_id "유저 대체ID"
varchar tid "카카오페이 결제고유번호"
varchar movie_title "영화제목"
bigint user_id FK "유저ID"
varchar type "결제 타입 - 예) 네이버페이, 카카오페이"
varchar status "상태 - 완료/환불"
varchar failed_message "실패사유"
varchar status "상태 - 완료/환불/실패"
varchar failed_message "실패사유 - 컬럼명을 알아보기 쉬운가?"
varchar payment_number "예매번호"
int total_price "결제 금액"
datetime deleted_at "삭제일시"
datetime created_at "결제일시"
datetime updated_at "수정일시"
}
USER ||--o{ PAYMENT : ""
USER {
bigint id "회원"
bigint alternate_id "대체ID"
varchar name "이름"
varchar email "이메일"
varchar password "비밀번호"
varchar grade "등급 - 고객/임직원"
varchar phone "휴대폰 번호"
boolean is_deleted "탈퇴여부"
datetime deleted_at "탈퇴일시"
datetime created_at "가입일시"
datetime updated_at "수정일시"
}
```
<br/><br/>

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,21 +9,21 @@ 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()
}
extra["springCloudVersion"] = "2021.0.3"
dependencies {
implementation("org.springframework.boot:spring-boot-starter-data-jpa")
@@ -32,67 +32,37 @@ dependencies {
implementation("org.springframework.boot:spring-boot-starter-web")
implementation("org.springframework.boot:spring-boot-starter-actuator")
implementation("org.springframework.boot:spring-boot-starter-log4j2")
implementation("org.projectlombok:lombok:1.18.24")
implementation("io.springfox:springfox-boot-starter:3.0.0")
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.4")
implementation("io.jsonwebtoken:jjwt-api:0.11.5")
implementation("com.googlecode.json-simple:json-simple:1.1.1")
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")
implementation("org.springframework.boot:spring-boot-starter-data-redis")
implementation("com.google.code.findbugs:jsr305:3.0.2")
implementation ("org.springframework.cloud:spring-cloud-starter-config")
implementation("org.springframework.cloud:spring-cloud-starter-openfeign")
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")
dependencyManagement {
imports {
mavenBom("org.springframework.cloud:spring-cloud-dependencies:${property("springCloudVersion")}")
}
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,15 +0,0 @@
package com.ticketing.server.global.config;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import org.springframework.security.test.context.support.WithSecurityContext;
@Retention(RetentionPolicy.RUNTIME)
@WithSecurityContext(factory = WithAuthUserSecurityContextFactory.class)
public @interface WithAuthUser {
String email();
String role();
}

View File

@@ -1,27 +0,0 @@
package com.ticketing.server.global.config;
import java.util.List;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.test.context.support.WithSecurityContextFactory;
public class WithAuthUserSecurityContextFactory implements WithSecurityContextFactory<WithAuthUser> {
@Override
public SecurityContext createSecurityContext(WithAuthUser annotation) {
String email = annotation.email();
String role = annotation.role();
List<SimpleGrantedAuthority> authorities = List.of(new SimpleGrantedAuthority(role));
User authUser = new User(email, "", authorities);
UsernamePasswordAuthenticationToken token =
new UsernamePasswordAuthenticationToken(authUser, "", authorities);
SecurityContext context = SecurityContextHolder.getContext();
context.setAuthentication(token);
return context;
}
}

View File

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

View File

@@ -1,242 +0,0 @@
package com.ticketing.server.user.application;
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.springSecurity;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ticketing.server.global.config.WithAuthUser;
import com.ticketing.server.user.application.request.LoginRequest;
import com.ticketing.server.user.application.request.SignUpRequest;
import com.ticketing.server.user.application.request.UserChangeGradeRequest;
import com.ticketing.server.user.application.request.UserChangePasswordRequest;
import com.ticketing.server.user.application.request.UserDeleteRequest;
import com.ticketing.server.user.domain.UserGrade;
import com.ticketing.server.user.domain.UserGrade.ROLES;
import com.ticketing.server.user.domain.repository.UserRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultActions;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.context.WebApplicationContext;
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
@Transactional
class UserControllerTest {
private static final String LOGIN_URL = "/api/auth/token";
private static final String BASICS_URL = "/api/users";
private static final String DETAILS_URL = "/api/users/details";
private static final String CHANGE_PASSWORD_URL = "/api/users/password";
private static final String CHANGE_GRADE_URL = "/api/users/grade";
private static final String NAME = "$.name";
private static final String EMAIL = "$.email";
private static final String GRADE = "$.grade";
private static final String PHONE = "$.phone";
private static final String BEFORE_GRADE = "$.beforeGrade";
private static final String AFTER_GRADE = "$.afterGrade";
private static final String USER_EMAIL = "testemail@ticketing.com";
private static final String USER_PW = "qwe123";
private static final String USER_NAME = "김철수";
private static final String USER_PHONE = "010-1234-5678";
@Autowired
UserRepository userRepository;
@Autowired
ObjectMapper mapper;
@Autowired
WebApplicationContext context;
MockMvc mvc;
SignUpRequest signUpRequest;
@Test
@DisplayName("회원가입 성공")
void registerSuccess() throws Exception {
// given
// when
ResultActions resultActions = mvc.perform(
post(BASICS_URL)
.content(mapper.writeValueAsString(signUpRequest))
.contentType(APPLICATION_JSON)
);
// then
resultActions
.andExpect(status().isCreated())
.andExpect(content().contentType(APPLICATION_JSON))
.andExpect(jsonPath(NAME).value(USER_NAME))
.andExpect(jsonPath(EMAIL).value(USER_EMAIL));
}
@Test
@DisplayName("유저 정보 조회")
@WithAuthUser(email = USER_EMAIL, role = ROLES.USER)
void detailsSuccess() throws Exception {
// given
mvc.perform(
post(BASICS_URL)
.content(mapper.writeValueAsString(signUpRequest))
.contentType(APPLICATION_JSON)
);
// when
ResultActions resultActions = mvc.perform(
get(DETAILS_URL)
.content(mapper.writeValueAsString(signUpRequest))
.contentType(APPLICATION_JSON)
);
// then
resultActions
.andExpect(status().isOk())
.andExpect(content().contentType(APPLICATION_JSON))
.andExpect(jsonPath(NAME).value(USER_NAME))
.andExpect(jsonPath(EMAIL).value(USER_EMAIL))
.andExpect(jsonPath(GRADE).value(UserGrade.USER.name()))
.andExpect(jsonPath(PHONE).value(USER_PHONE));
}
@Test
@DisplayName("유저 탈퇴 성공")
@WithAuthUser(email = USER_EMAIL, role = ROLES.USER)
void deleteUserSuccess() throws Exception {
// given
UserDeleteRequest deleteRequest = new UserDeleteRequest(USER_EMAIL, USER_PW);
LoginRequest loginRequest = new LoginRequest(USER_EMAIL, USER_PW);
mvc.perform(
post(BASICS_URL)
.content(mapper.writeValueAsString(signUpRequest))
.contentType(APPLICATION_JSON)
);
// when
// 1. 회원 탈퇴 진행
mvc.perform(
delete(BASICS_URL)
.content(mapper.writeValueAsString(deleteRequest))
.contentType(APPLICATION_JSON)
);
// 2. 탈퇴된 계정 로그인
ResultActions resultActions = mvc.perform(post(LOGIN_URL)
.content(mapper.writeValueAsString(loginRequest))
.contentType(MediaType.APPLICATION_JSON));
// then
resultActions
.andExpect(status().isUnauthorized());
}
@Test
@DisplayName("비밀번호 변경 성공")
@WithAuthUser(email = USER_EMAIL, role = ROLES.USER)
void changePasswordSuccess() throws Exception {
// given
UserChangePasswordRequest changePasswordRequest = new UserChangePasswordRequest(USER_PW, "qwe1234");
LoginRequest loginRequest = new LoginRequest(USER_EMAIL, USER_PW);
mvc.perform(
post(BASICS_URL)
.content(mapper.writeValueAsString(this.signUpRequest))
.contentType(APPLICATION_JSON)
);
// when
// 1. 패스워드 변경
mvc.perform(
put(CHANGE_PASSWORD_URL)
.content(mapper.writeValueAsString(changePasswordRequest))
.contentType(APPLICATION_JSON)
)
.andExpect(status().isOk());
// 2. 변경 전 계정으로 로그인
ResultActions resultActions = mvc.perform(post(LOGIN_URL)
.content(mapper.writeValueAsString(loginRequest))
.contentType(MediaType.APPLICATION_JSON));
// then
resultActions
.andExpect(status().isUnauthorized());
}
@Test
@DisplayName("유저 등급 변경")
@WithAuthUser(email = "admin@ticketing.com", role = ROLES.ADMIN)
void changeGradeSuccess() throws Exception {
// given
UserChangeGradeRequest changeGradeRequest = new UserChangeGradeRequest(USER_EMAIL, UserGrade.STAFF);
mvc.perform(
post(BASICS_URL)
.content(mapper.writeValueAsString(signUpRequest))
.contentType(APPLICATION_JSON)
);
// when
ResultActions resultActions = mvc.perform(
post(CHANGE_GRADE_URL)
.content(mapper.writeValueAsString(changeGradeRequest))
.contentType(APPLICATION_JSON)
);
// then
resultActions
.andExpect(status().isOk())
.andExpect(content().contentType(APPLICATION_JSON))
.andExpect(jsonPath(EMAIL).value(USER_EMAIL))
.andExpect(jsonPath(BEFORE_GRADE).value(UserGrade.USER.name()))
.andExpect(jsonPath(AFTER_GRADE).value(UserGrade.STAFF.name()));
}
@Test
@DisplayName("유저 등급 변경 실패 - 권한 등급이 낮을 경우")
@WithAuthUser(email = "staff@ticketing.com", role = ROLES.STAFF)
void changeGradeFail() throws Exception {
// given
UserChangeGradeRequest changeGradeRequest = new UserChangeGradeRequest(USER_EMAIL, UserGrade.STAFF);
// when
ResultActions resultActions = mvc.perform(
post(CHANGE_GRADE_URL)
.content(mapper.writeValueAsString(changeGradeRequest))
.contentType(APPLICATION_JSON)
);
// then
resultActions
.andExpect(status().isForbidden());
}
@BeforeEach
void init() {
mvc = MockMvcBuilders
.webAppContextSetup(context)
.apply(springSecurity())
.build();
signUpRequest = new SignUpRequest(USER_NAME, USER_EMAIL, USER_PW, USER_PHONE);
}
}

View File

@@ -1,40 +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
config:
import: "optional:configserver:"
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,17 +1,14 @@
package com.ticketing.server;
import com.ticketing.server.global.security.jwt.JwtProperties;
import com.ticketing.server.payment.api.KakaoPayProperties;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
@EnableJpaAuditing
@EnableFeignClients
@SpringBootApplication
@EnableConfigurationProperties({JwtProperties.class, KakaoPayProperties.class})
@EnableConfigurationProperties(JwtProperties.class)
public class ServerApplication {
public static void main(String[] args) {

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

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

View File

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

View File

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

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

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

View File

@@ -1,158 +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.FORBIDDEN;
import static org.springframework.http.HttpStatus.NOT_FOUND;
import com.ticketing.server.global.redis.PaymentCache;
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, "사용할 수 없는 토큰 입니다."),
UNABLE_CHANGE_GRADE(BAD_REQUEST, "동일한 등급으로 변경할 수 없습니다."),
INVALID_TICKET_ID(BAD_REQUEST, "잘못된 티켓 ID가 존재합니다."),
BAD_REQUEST_MOVIE_TIME(BAD_REQUEST, "동일한 상영시간만 결제 가능합니다."),
BAD_REQUEST_PAYMENT_COMPLETE(BAD_REQUEST, "처리할 결제 정보가 존재하지 않습니다."),
BAD_REQUEST_PAYMENT_READY(BAD_REQUEST, "이미 진행 중인 결제가 존재합니다."),
BAD_REQUEST_PAYMENT_CANCEL(BAD_REQUEST, "취소할 티켓이 존재하지 않습니다."),
NOT_REFUNDABLE_TIME(BAD_REQUEST, "환불이 가능한 시간이 지났습니다."),
NOT_REFUNDABLE_SEAT(BAD_REQUEST, "환불할 수 있는 좌석이 아닙니다."),
/* 403 FORBIDDEN : 접근 권한 제한 */
VALID_USER_ID(FORBIDDEN, "해당 정보에 접근 권한이 존재하지 않습니다."),
/* 404 NOT_FOUND : Resource 를 찾을 수 없음 */
USER_NOT_FOUND(NOT_FOUND, "해당 유저 정보를 찾을 수 없습니다."),
EMAIL_NOT_FOUND(NOT_FOUND, "해당 이메일을 찾을 수 없습니다."),
MOVIE_NOT_FOUND(NOT_FOUND, "해당 제목의 영화를 찾을 수 없습니다."),
MOVIE_TIME_NOT_FOUND(NOT_FOUND, "해당 영화 시간표 정보를 찾을 수 없습니다"),
REFRESH_TOKEN_NOT_FOUND(NOT_FOUND, "리프레쉬 토큰을 찾을 수 없습니다."),
PAYMENT_ID_NOT_FOUND(NOT_FOUND, "결제정보를 찾을 수 없습니다."),
THEATER_NOT_FOUND(NOT_FOUND, "상영관 정보를 찾을 수 없습니다."),
/* 409 CONFLICT : Resource 의 현재 상태와 충돌. 보통 중복된 데이터 존재 */
DUPLICATE_EMAIL(CONFLICT, "이메일이 이미 존재합니다."),
DUPLICATE_PAYMENT(CONFLICT, "해당 좌석은 현재 판매된 좌석입니다."),
DUPLICATE_MOVIE(CONFLICT, "해당 영화 정보가 이미 존재합니다."),
DUPLICATE_MOVIE_TIME(CONFLICT, "해당 영화 시간표 정보가 이미 존재합니다."),
DELETED_EMAIL(CONFLICT, "이미 삭제된 이메일 입니다."),
DELETED_MOVIE(CONFLICT, "이미 삭제된 영화 입니다.");
private final HttpStatus httpStatus;
private String detail;
/* 400 BAD_REQUEST : 잘못된 요청 */
public static TicketingException throwMismatchPassword() {
throw new TicketingException(MISMATCH_PASSWORD);
}
public static TicketingException throwTokenType() {
throw new TicketingException(TOKEN_TYPE);
}
public static TicketingException throwUnavailableRefreshToken() {
throw new TicketingException(UNAVAILABLE_REFRESH_TOKEN);
}
public static TicketingException throwUnableChangeGrade() {
throw new TicketingException(UNABLE_CHANGE_GRADE);
}
public static TicketingException throwInvalidTicketId() {
throw new TicketingException(INVALID_TICKET_ID);
}
public static TicketingException throwBadRequestMovieTime() {
throw new TicketingException(BAD_REQUEST_MOVIE_TIME);
}
public static TicketingException throwBadRequestPaymentComplete() {
throw new TicketingException(BAD_REQUEST_PAYMENT_COMPLETE);
}
public static TicketingException throwBadRequestPaymentReady() {
throw new TicketingException(BAD_REQUEST_PAYMENT_READY);
}
public static TicketingException throwBadRequestPaymentCancel() {
throw new TicketingException(BAD_REQUEST_PAYMENT_CANCEL);
}
public static TicketingException throwNotRefundableTime() {
throw new TicketingException(NOT_REFUNDABLE_TIME);
}
public static TicketingException throwNotRefundableSeat() {
throw new TicketingException(NOT_REFUNDABLE_SEAT);
}
/* 403 FORBIDDEN : 접근 권한 제한 */
public static TicketingException throwValidUserId() {
throw new TicketingException(VALID_USER_ID);
}
/* 404 NOT_FOUND : Resource 를 찾을 수 없음 */
public static TicketingException throwUserNotFound() {
throw new TicketingException(USER_NOT_FOUND);
}
public static TicketingException throwEmailNotFound() {
throw new TicketingException(EMAIL_NOT_FOUND);
}
public static TicketingException throwMovieNotFound() {
throw new TicketingException(MOVIE_NOT_FOUND);
}
public static TicketingException throwMovieTimeNotFound() {
throw new TicketingException(MOVIE_TIME_NOT_FOUND);
}
public static TicketingException throwRefreshTokenNotFound() {
throw new TicketingException(REFRESH_TOKEN_NOT_FOUND);
}
public static TicketingException throwPaymentIdNotFound() {
throw new TicketingException(PAYMENT_ID_NOT_FOUND);
}
public static TicketingException throwTheaterNotFound() {
throw new TicketingException(THEATER_NOT_FOUND);
}
/* 409 CONFLICT : Resource 의 현재 상태와 충돌. 보통 중복된 데이터 존재 */
public static TicketingException throwDuplicateEmail() {
throw new TicketingException(DUPLICATE_EMAIL);
}
public static TicketingException throwDuplicatePayment() {
throw new TicketingException(DUPLICATE_PAYMENT);
}
public static TicketingException throwDuplicateMovie() {
throw new TicketingException(DUPLICATE_MOVIE);
}
public static TicketingException throwDuplicateMovieTime() {
throw new TicketingException(DUPLICATE_MOVIE_TIME);
}
public static TicketingException throwDeletedEmail() {
throw new TicketingException(DELETED_EMAIL);
}
public static TicketingException throwDeletedMovie() {
throw new TicketingException(DELETED_MOVIE);
}
}

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,258 +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.authentication.BadCredentialsException;
import org.springframework.security.core.AuthenticationException;
import org.springframework.validation.BindException;
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 ResponseEntity.status(response.getStatus()).headers(headers).body(response);
}
/***
* 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 ResponseEntity.status(response.getStatus()).headers(headers).body(response);
}
/**
* 잘못된 유형으로 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 = BadCredentialsException.class)
protected ResponseEntity<ErrorResponse> handleBadCredentialsException(BadCredentialsException ex) {
log.error("BadCredentialsException :: ", ex);
ErrorResponse response = new ErrorResponse(UNAUTHORIZED, 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(error.getDefaultMessage());
}
return errors;
}
}

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

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

View File

@@ -0,0 +1,10 @@
package com.ticketing.server.global.exception.token;
public class TokenNotFindException extends TokenException {
private static final String MESSAGE = "일치하는 토큰을 찾지 못하였습니다.";
public TokenNotFindException() {
super(MESSAGE);
}
}

View File

@@ -0,0 +1,10 @@
package com.ticketing.server.global.exception.token;
public class TokenTypeException extends TokenException {
private static final String MESSAGE = "토큰 타입이 일치하지 않습니다.";
public TokenTypeException() {
super(MESSAGE);
}
}

View File

@@ -0,0 +1,11 @@
package com.ticketing.server.global.exception.token;
public class UnavailableRefreshTokenException extends TokenException {
private static final String MESSAGE = "사용할 수 없는 refresh Token 입니다.";
public UnavailableRefreshTokenException() {
super(MESSAGE);
}
}

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,47 +0,0 @@
package com.ticketing.server.global.redis;
import java.util.List;
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("Payment")
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class PaymentCache {
@Id
@GeneratedValue
@Column(name = "payment_ready_id")
private Long id;
@Indexed
private String email;
private String movieTitle;
private String tid;
private List<Long> ticketIds;
private Long userAlternateId;
private Long paymentNumber;
private Integer totalAmount;
public PaymentCache(String email, String movieTitle, String tid, List<Long> ticketIds, Long userAlternateId, Long paymentNumber, Integer totalAmount) {
this.email = email;
this.movieTitle = movieTitle;
this.tid = tid;
this.ticketIds = ticketIds;
this.userAlternateId = userAlternateId;
this.paymentNumber = paymentNumber;
this.totalAmount = totalAmount;
}
}

View File

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

View File

@@ -3,14 +3,10 @@ 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.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
@@ -45,21 +41,4 @@ public class RedisConfig {
return new JpaTransactionManager();
}
@Bean
public RedisCacheManager redisCacheManager() {
RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
.serializeKeysWith(
RedisSerializationContext.SerializationPair.fromSerializer(
new StringRedisSerializer()))
.serializeValuesWith(
RedisSerializationContext.SerializationPair.fromSerializer(
new GenericJackson2JsonRedisSerializer()));
return RedisCacheManager.RedisCacheManagerBuilder
.fromConnectionFactory(redisConnectionFactory())
.cacheDefaults(redisCacheConfiguration)
.build();
}
}

View File

@@ -50,14 +50,13 @@ 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(HttpMethod.POST, "/api/user/login").permitAll()
.antMatchers(HttpMethod.POST, "/api/user/refresh").permitAll()
.antMatchers(HttpMethod.POST, "/api/user").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

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

View File

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

View File

@@ -3,24 +3,15 @@ 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.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

@@ -3,24 +3,15 @@ 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.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")
@Component
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);
response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
}
}

View File

@@ -1,4 +1,4 @@
package com.ticketing.server.user.service;
package com.ticketing.server.global.security.service;
import com.ticketing.server.user.domain.User;
import com.ticketing.server.user.domain.repository.UserRepository;
@@ -18,9 +18,9 @@ public class CustomUserDetailsService implements UserDetailsService {
@Override
public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
return userRepository.findByEmailAndDeletedAtNull(email)
return userRepository.findByEmailAndIsDeletedFalse(email)
.map(this::createUserDetails)
.orElseThrow(() -> new UsernameNotFoundException(email));
.orElseThrow(() -> new UsernameNotFoundException("존재하지 않는 email 입니다. :: " + email));
}
private UserDetails createUserDetails(User user) {
@@ -32,5 +32,4 @@ public class CustomUserDetailsService implements UserDetailsService {
, Collections.singleton(grantedAuthority)
);
}
}

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() default "validation.password.not.change";
String field();
String fieldMatch();
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}

View File

@@ -1,22 +0,0 @@
package com.ticketing.server.global.validator.constraints;
import com.ticketing.server.global.validator.constraintvalidators.NotEmptyCollectionValidator;
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;
@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = NotEmptyCollectionValidator.class)
public @interface NotEmptyCollection {
String message() default "목록이 존재하지 않습니다.";
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,20 +0,0 @@
package com.ticketing.server.global.validator.constraintvalidators;
import com.ticketing.server.global.validator.constraints.NotEmptyCollection;
import java.util.Collection;
import java.util.Objects;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
public class NotEmptyCollectionValidator implements ConstraintValidator<NotEmptyCollection, Collection<Long>> {
@Override
public boolean isValid(Collection<Long> objects, ConstraintValidatorContext context) {
if (objects.isEmpty()) {
return false;
}
return objects.stream().allMatch(Objects::nonNull);
}
}

View File

@@ -1,74 +1,8 @@
package com.ticketing.server.movie.application;
import static com.ticketing.server.user.domain.UserGrade.ROLES.STAFF;
import com.ticketing.server.movie.application.request.MovieDeleteRequest;
import com.ticketing.server.movie.application.request.MovieRegisterRequest;
import com.ticketing.server.movie.application.response.MovieDeleteResponse;
import com.ticketing.server.movie.application.response.MovieListResponse;
import com.ticketing.server.movie.application.response.MovieInfoResponse;
import com.ticketing.server.movie.service.dto.DeletedMovieDTO;
import com.ticketing.server.movie.service.dto.MovieDTO;
import com.ticketing.server.movie.service.dto.RegisteredMovieDTO;
import com.ticketing.server.movie.service.interfaces.MovieService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import java.util.List;
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.DeleteMapping;
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(STAFF)
public ResponseEntity<MovieInfoResponse> registerMovie(@RequestBody @Valid MovieRegisterRequest request) {
RegisteredMovieDTO registeredMovieDto =
movieService.registerMovie(request.getTitle(), request.getRunningTime());
return ResponseEntity.status(HttpStatus.OK)
.body(
registeredMovieDto.toResponse()
);
}
@GetMapping()
@ApiOperation(value = "영화 목록 조회")
public ResponseEntity<MovieListResponse> getMovies() {
List<MovieDTO> movieDtos = movieService.getMovies();
return ResponseEntity.status(HttpStatus.OK)
.body(
new MovieListResponse(movieDtos)
);
}
@DeleteMapping()
@ApiOperation(value = "영화 정보 삭제")
@Secured(STAFF)
public ResponseEntity<MovieDeleteResponse> deleteMovie(@RequestBody @Valid MovieDeleteRequest request) {
DeletedMovieDTO deletedMovieDto = movieService.deleteMovie(request.getId());
return ResponseEntity.status(HttpStatus.OK)
.body(
deletedMovieDto.toResponse()
);
}
}

View File

@@ -1,70 +0,0 @@
package com.ticketing.server.movie.application;
import static com.ticketing.server.user.domain.UserGrade.ROLES.STAFF;
import com.ticketing.server.movie.application.request.MovieTimeRegisterRequest;
import com.ticketing.server.movie.application.response.MovieTimeInfoResponse;
import com.ticketing.server.movie.application.response.MovieTimeListResponse;
import com.ticketing.server.movie.service.dto.MovieTimeDTO;
import com.ticketing.server.movie.service.dto.RegisteredMovieTimeDTO;
import com.ticketing.server.movie.service.interfaces.MovieTimeService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import java.time.LocalDate;
import java.util.List;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.annotation.Secured;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api/movieTimes")
@Api(value = "MovieTime API", tags = {"Movie Time"})
@RequiredArgsConstructor
@Slf4j
public class MovieTimeController {
private final MovieTimeService movieTimeService;
@PostMapping
@ApiOperation(value = "영화 시간표 등록")
@Secured(STAFF)
public ResponseEntity<MovieTimeInfoResponse> registerMovieTime(
@RequestBody @Valid MovieTimeRegisterRequest movieTimeRegisterRequest) {
RegisteredMovieTimeDTO registeredMovieTimeDto = movieTimeService.registerMovieTime(
movieTimeRegisterRequest.toMovieTimeRegisterDTO()
);
return ResponseEntity.status(HttpStatus.OK)
.body(
registeredMovieTimeDto.toResponse()
);
}
@GetMapping
@ApiOperation(value = "영화 시간표 조회")
@Validated
public ResponseEntity<MovieTimeListResponse> getMovieTimes(
@ApiParam(value = "영화 ID", required = true) @RequestParam @NotNull Long movieId,
@ApiParam(value = "상영 날짜", required = true) @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate runningDate) {
List<MovieTimeDTO> movieTimeDtos = movieTimeService.getMovieTimes(movieId, runningDate);
return ResponseEntity.status(HttpStatus.OK)
.body(
new MovieTimeListResponse(movieTimeDtos)
);
}
}

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,56 +1,8 @@
package com.ticketing.server.movie.application;
import static com.ticketing.server.user.domain.UserGrade.ROLES.USER;
import com.ticketing.server.movie.application.response.TicketDetailsResponse;
import com.ticketing.server.movie.application.response.TicketListResponse;
import com.ticketing.server.movie.service.dto.TicketDTO;
import com.ticketing.server.movie.service.interfaces.TicketService;
import com.ticketing.server.payment.service.dto.TicketDetailDTO;
import io.swagger.annotations.ApiParam;
import java.util.List;
import javax.validation.constraints.NotNull;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.annotation.Secured;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
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/tickets")
@Validated
public class TicketController {
private final TicketService ticketService;
@GetMapping
@Secured(USER)
public ResponseEntity<TicketListResponse> getTickets(
@ApiParam(value = "영화 시간표 ID", required = true) @RequestParam @NotNull Long movieTimeId) {
List<TicketDTO> tickets = ticketService.getTickets(movieTimeId);
return ResponseEntity.status(HttpStatus.OK)
.body(
new TicketListResponse(tickets)
);
}
@GetMapping("/payments/{paymentId}")
@Secured(USER)
public ResponseEntity<TicketDetailsResponse> findTicketsByPaymentId(
@PathVariable("paymentId") @NotNull Long paymentId) {
List<TicketDetailDTO> tickets = ticketService.findTicketsByPaymentId(paymentId);
return ResponseEntity.status(HttpStatus.OK)
.body(
new TicketDetailsResponse(tickets)
);
}
}

View File

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

View File

@@ -1,23 +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;
@Getter
@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(title, runningTime);
}
}

View File

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

View File

@@ -1,13 +0,0 @@
package com.ticketing.server.movie.application.request;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public class TicketCancelRequest {
private final List<Long> ticketIds;
}

View File

@@ -1,15 +0,0 @@
package com.ticketing.server.movie.application.request;
import com.ticketing.server.global.validator.constraints.NotEmptyCollection;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public class TicketReservationRequest {
@NotEmptyCollection
private List<Long> ticketIds;
}

View File

@@ -1,19 +0,0 @@
package com.ticketing.server.movie.application.request;
import com.ticketing.server.global.validator.constraints.NotEmptyCollection;
import java.util.List;
import javax.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public class TicketSoldRequest {
@NotNull
private Long paymentId;
@NotEmptyCollection
private List<Long> ticketIds;
}

View File

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

View File

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

View File

@@ -1,16 +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.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public class MovieListResponse {
@ApiModelProperty(value = "영화 목록")
private List<MovieDTO> movieDtos;
}

View File

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

View File

@@ -1,17 +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
public class MovieTimeListResponse {
@ApiModelProperty(value = "영화 시간표 목록")
private List<MovieTimeDTO> movieTimeDtos;
}

View File

@@ -1,13 +0,0 @@
package com.ticketing.server.movie.application.response;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public class TicketCancelResponse {
private final List<Long> ticketIds;
}

View File

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

View File

@@ -1,16 +0,0 @@
package com.ticketing.server.movie.application.response;
import com.ticketing.server.movie.service.dto.TicketDTO;
import io.swagger.annotations.ApiModelProperty;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public class TicketListResponse {
@ApiModelProperty(value = "티켓 목록")
private List<TicketDTO> ticketDtos;
}

View File

@@ -1,25 +0,0 @@
package com.ticketing.server.movie.application.response;
import com.ticketing.server.movie.service.dto.TicketReservationDTO;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public class TicketReservationResponse {
private final String movieTitle;
private final List<TicketReservationDTO> tickets;
public int getTicketQuantity() {
return tickets.size();
}
public int getTotalPrice() {
return tickets.stream()
.mapToInt(TicketReservationDTO::getTicketPrice)
.sum();
}
}

View File

@@ -1,15 +0,0 @@
package com.ticketing.server.movie.application.response;
import com.ticketing.server.movie.service.dto.TicketSoldDTO;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public class TicketSoldResponse {
private final Long paymentId;
private final List<TicketSoldDTO> soldDtoList;
}

View File

@@ -1,46 +1,24 @@
package com.ticketing.server.movie.domain;
import com.ticketing.server.global.dto.repository.AbstractEntity;
import com.ticketing.server.global.exception.ErrorCode;
import com.ticketing.server.movie.service.dto.MovieDTO;
import java.time.LocalDateTime;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.validation.constraints.NotNull;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Entity
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@NoArgsConstructor
@AllArgsConstructor
public class Movie extends AbstractEntity {
@NotNull
private String title;
@NotNull
@Column(unique = true)
private String title;
@NotNull
private Long runningTime;
Movie(Long id, String title, Long runningTime) {
this.id = id;
this.title = title;
this.runningTime = runningTime;
}
public Movie delete() {
if (deletedAt != null) {
throw ErrorCode.throwDeletedMovie();
}
deletedAt = LocalDateTime.now();
return this;
}
public MovieDTO toMovieDTO() {
return new MovieDTO(this.id, this.title);
}
@NotNull
private Integer runningTime;
}

View File

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

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

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

View File

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

View File

@@ -1,141 +1,35 @@
package com.ticketing.server.movie.domain;
import com.ticketing.server.global.dto.repository.AbstractEntity;
import com.ticketing.server.global.exception.ErrorCode;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import com.ticketing.server.payment.domain.Payment;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.validation.constraints.NotNull;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Entity
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Ticket extends AbstractEntity {
@NotNull
@ManyToOne(fetch = FetchType.LAZY)
@ManyToOne
@JoinColumn(name = "seat_id", referencedColumnName = "id", updatable = false)
private Seat seat;
@NotNull
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "movie_time_id", referencedColumnName = "id", updatable = false)
private MovieTime movieTime;
@ManyToOne
@JoinColumn(name = "movie_times_id", referencedColumnName = "id", updatable = false)
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;
public Ticket(Seat seat, MovieTime movieTime, Integer ticketPrice) {
this.seat = seat;
this.movieTime = movieTime;
this.ticketPrice = ticketPrice;
this.status = TicketStatus.SALE;
}
Ticket(Long id, Seat seat, MovieTime movieTime, Integer ticketPrice) {
this.id = id;
this.seat = seat;
this.movieTime = movieTime;
this.ticketPrice = ticketPrice;
this.status = TicketStatus.SALE;
}
public Ticket makeReservation() {
if (!TicketStatus.SALE.equals(status)) {
throw ErrorCode.throwDuplicatePayment();
}
status = TicketStatus.RESERVATION;
return this;
}
public Ticket makeSold(Long paymentId) {
if (TicketStatus.SOLD.equals(status)) {
throw ErrorCode.throwDuplicatePayment();
}
status = TicketStatus.SOLD;
this.paymentId = paymentId;
return this;
}
public Ticket cancel() {
if (!TicketStatus.RESERVATION.equals(status)) {
throw ErrorCode.throwBadRequestPaymentCancel();
}
status = TicketStatus.SALE;
paymentId = null;
return this;
}
public Ticket refund(LocalDateTime dateTime) {
long seconds = ChronoUnit.SECONDS.between(dateTime, getStartAt());
if (600L > seconds) {
throw ErrorCode.throwNotRefundableTime();
}
return refund();
}
public Ticket refund() {
if (!TicketStatus.SOLD.equals(status)) {
throw ErrorCode.throwNotRefundableSeat();
}
status = TicketStatus.SALE;
paymentId = null;
return this;
}
public Long getMovieTimeId() {
return movieTime.getId();
}
public Integer getColumn() {
return this.seat.getSeatColumn();
}
public Integer getRow() {
return this.seat.getSeatRow();
}
public LocalDateTime getStartAt() {
return this.movieTime.getStartAt();
}
public LocalDateTime getEndAt() {
return this.movieTime.getEndAt();
}
public Integer getTheaterNumber() {
return this.seat.getTheaterNumber();
}
public String getMovieTitle() {
return this.movieTime.getMovieTitle();
}
public void registerPayment(Long id) {
if (this.paymentId != null) {
throw ErrorCode.throwDuplicatePayment();
}
this.paymentId = id;
}
}

View File

@@ -2,16 +2,14 @@ package com.ticketing.server.movie.domain;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
@Getter
@RequiredArgsConstructor
@AllArgsConstructor
public enum TicketStatus {
SALE("판매가능"),
SCHEDULED("환불"),
SOLD("판매완료");
SALE("판매가능"),
RESERVATION("예약"),
SOLD("판매완료");
private final String name;
private String name;
}

View File

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

View File

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

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,43 +1,10 @@
package com.ticketing.server.movie.domain.repository;
import com.ticketing.server.movie.domain.MovieTime;
import com.ticketing.server.movie.domain.Ticket;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
@Repository
public interface TicketRepository extends JpaRepository<Ticket, Long> {
@Query(
value = "SELECT t "
+ "FROM Ticket t "
+ "JOIN FETCH t.seat s "
+ "WHERE t.movieTime = :movieTime "
+ "AND t.deletedAt IS NULL"
)
List<Ticket> findValidTickets(MovieTime movieTime);
@Query(
value = "SELECT t "
+ "FROM Ticket t "
+ "JOIN FETCH t.movieTime mt "
+ "JOIN FETCH t.seat s "
+ "JOIN FETCH s.theater th "
+ "WHERE t.paymentId = :paymentId "
)
List<Ticket> findTicketFetchJoinByPaymentId(@Param("paymentId") Long paymentId);
@Query(
value = "SELECT t "
+ "FROM Ticket t "
+ "JOIN FETCH t.movieTime mt "
+ "JOIN FETCH t.seat s "
+ "JOIN FETCH s.theater th "
+ "WHERE t.id IN (:ticketIds) "
)
List<Ticket> findTicketFetchJoinByTicketIds(@Param("ticketIds") List<Long> ticketIds);
}

View File

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

View File

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

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,136 +1,9 @@
package com.ticketing.server.movie.service;
import com.ticketing.server.global.exception.ErrorCode;
import com.ticketing.server.global.validator.constraints.NotEmptyCollection;
import com.ticketing.server.movie.domain.MovieTime;
import com.ticketing.server.movie.domain.Ticket;
import com.ticketing.server.movie.domain.repository.MovieTimeRepository;
import com.ticketing.server.movie.domain.repository.TicketRepository;
import com.ticketing.server.movie.service.dto.TicketDTO;
import com.ticketing.server.movie.service.dto.TicketRefundDTO;
import com.ticketing.server.movie.service.dto.TicketReservationDTO;
import com.ticketing.server.movie.service.dto.TicketSoldDTO;
import com.ticketing.server.movie.service.dto.TicketsCancelDTO;
import com.ticketing.server.movie.service.dto.TicketsReservationDTO;
import com.ticketing.server.movie.service.dto.TicketsSoldDTO;
import com.ticketing.server.movie.service.interfaces.TicketService;
import com.ticketing.server.payment.service.dto.TicketDetailDTO;
import java.util.List;
import java.util.function.UnaryOperator;
import java.util.stream.Collectors;
import javax.validation.constraints.NotNull;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
@Validated
@Slf4j
public class TicketServiceImpl implements TicketService {
private final TicketRepository ticketRepository;
private final MovieTimeRepository movieTimeRepository;
@Override
public List<TicketDTO> getTickets(@NotNull Long movieTimeId) {
MovieTime movieTime = movieTimeRepository.findById(movieTimeId)
.orElseThrow(ErrorCode::throwMovieTimeNotFound);
return ticketRepository.findValidTickets(movieTime)
.stream()
.map(TicketDTO::new)
.collect(Collectors.toList());
}
@Override
public List<TicketDetailDTO> findTicketsByPaymentId(@NotNull Long paymentId) {
List<TicketDetailDTO> ticketDetails = ticketRepository.findTicketFetchJoinByPaymentId(paymentId)
.stream()
.map(TicketDetailDTO::new)
.collect(Collectors.toList());
if (ticketDetails.isEmpty()) {
throw ErrorCode.throwPaymentIdNotFound();
}
return ticketDetails;
}
@Override
@Transactional
public TicketsReservationDTO ticketReservation(@NotEmptyCollection List<Long> ticketIds) {
List<Ticket> tickets = getTicketsByInTicketIds(ticketIds);
Long firstMovieTimeId = firstMovieTimeId(tickets);
List<TicketReservationDTO> reservationDtoList = tickets.stream()
.map(Ticket::makeReservation)
.filter(ticket -> firstMovieTimeId.equals(ticket.getMovieTimeId()))
.map(TicketReservationDTO::new)
.collect(Collectors.toList());
if (ticketIds.size() != reservationDtoList.size()) {
throw ErrorCode.throwBadRequestMovieTime();
}
return new TicketsReservationDTO(firstMovieTitle(tickets), reservationDtoList);
}
@Override
@Transactional
public TicketsSoldDTO ticketSold(@NotNull Long paymentId, @NotEmptyCollection List<Long> ticketIds) {
List<Ticket> tickets = getTicketsByInTicketIds(ticketIds);
List<TicketSoldDTO> soldDtoList = tickets.stream()
.map(ticket -> ticket.makeSold(paymentId))
.map(TicketSoldDTO::new)
.collect(Collectors.toList());
return new TicketsSoldDTO(paymentId, soldDtoList);
}
@Override
@Transactional
public TicketsCancelDTO ticketCancel(@NotEmptyCollection List<Long> ticketIds) {
List<Ticket> tickets = getTicketsByInTicketIds(ticketIds);
tickets.forEach(Ticket::cancel);
return new TicketsCancelDTO(tickets);
}
@Override
@Transactional
public List<TicketRefundDTO> ticketsRefund(@NotNull Long paymentId, UnaryOperator<Ticket> refund) {
List<Ticket> tickets = ticketRepository.findTicketFetchJoinByPaymentId(paymentId);
return tickets.stream()
.map(refund)
.map(TicketRefundDTO::new)
.collect(Collectors.toList());
}
private List<Ticket> getTicketsByInTicketIds(List<Long> ticketIds) {
List<Ticket> tickets = ticketRepository.findTicketFetchJoinByTicketIds(ticketIds);
if (tickets.size() != ticketIds.size()) {
throw ErrorCode.throwInvalidTicketId();
}
return tickets;
}
private Long firstMovieTimeId(List<Ticket> tickets) {
Ticket ticket = tickets.get(0);
return ticket.getMovieTimeId();
}
private String firstMovieTitle(List<Ticket> tickets) {
Ticket ticket = tickets.get(0);
return ticket.getMovieTitle();
}
}

View File

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

View File

@@ -1,14 +0,0 @@
package com.ticketing.server.movie.service.dto;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public class MovieDTO {
private Long movieId;
private String title;
}

View File

@@ -1,25 +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,21 +0,0 @@
package com.ticketing.server.movie.service.dto;
import java.time.LocalDateTime;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public class MovieTimeDTO {
private Long movieTimeId;
private Integer theaterNumber;
private Integer round;
private LocalDateTime startAt;
private LocalDateTime endAt;
}

View File

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

View File

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

View File

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

View File

@@ -1,33 +0,0 @@
package com.ticketing.server.movie.service.dto;
import com.ticketing.server.movie.domain.Ticket;
import com.ticketing.server.movie.domain.TicketStatus;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class TicketDTO {
private Long ticketId;
private Integer ticketPrice;
private Integer seatRow;
private Integer seatColumn;
private TicketStatus status;
public TicketDTO(Ticket ticket) {
this(
ticket.getId(),
ticket.getTicketPrice(),
ticket.getRow(),
ticket.getColumn(),
ticket.getStatus()
);
}
}

View File

@@ -1,20 +0,0 @@
package com.ticketing.server.movie.service.dto;
import com.ticketing.server.movie.domain.Ticket;
import com.ticketing.server.movie.domain.TicketStatus;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class TicketRefundDTO {
private Long ticketId;
private TicketStatus ticketStatus;
public TicketRefundDTO(Ticket ticket) {
this(ticket.getId(), ticket.getStatus());
}
}

View File

@@ -1,19 +0,0 @@
package com.ticketing.server.movie.service.dto;
import com.ticketing.server.movie.domain.Ticket;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class TicketReservationDTO {
private final Long ticketId;
private final Integer ticketPrice;
public TicketReservationDTO(Ticket ticket) {
this(ticket.getId(), ticket.getTicketPrice());
}
}

View File

@@ -1,19 +0,0 @@
package com.ticketing.server.movie.service.dto;
import com.ticketing.server.movie.domain.Ticket;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class TicketSoldDTO {
private final Long ticketId;
private final Integer ticketPrice;
public TicketSoldDTO(Ticket ticket) {
this(ticket.getId(), ticket.getTicketPrice());
}
}

View File

@@ -1,24 +0,0 @@
package com.ticketing.server.movie.service.dto;
import com.ticketing.server.movie.application.response.TicketCancelResponse;
import com.ticketing.server.movie.domain.Ticket;
import java.util.List;
import java.util.stream.Collectors;
import lombok.Getter;
@Getter
public class TicketsCancelDTO {
private final List<Long> ticketIds;
public TicketsCancelDTO(List<Ticket> tickets) {
ticketIds = tickets.stream()
.map(Ticket::getId)
.collect(Collectors.toList());
}
public TicketCancelResponse toResponse() {
return new TicketCancelResponse(ticketIds);
}
}

View File

@@ -1,21 +0,0 @@
package com.ticketing.server.movie.service.dto;
import java.util.List;
import java.util.stream.Collectors;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public class TicketsRefundResponse {
private final List<TicketRefundDTO> tickets;
public List<Long> getTicketIds() {
return tickets.stream()
.mapToLong(TicketRefundDTO::getTicketId)
.boxed()
.collect(Collectors.toList());
}
}

View File

@@ -1,19 +0,0 @@
package com.ticketing.server.movie.service.dto;
import com.ticketing.server.movie.application.response.TicketReservationResponse;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public class TicketsReservationDTO {
private final String movieTitle;
private final List<TicketReservationDTO> ticketReservationDtoList;
public TicketReservationResponse toResponse() {
return new TicketReservationResponse(movieTitle, ticketReservationDtoList);
}
}

View File

@@ -1,19 +0,0 @@
package com.ticketing.server.movie.service.dto;
import com.ticketing.server.movie.application.response.TicketSoldResponse;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public class TicketsSoldDTO {
private final Long paymentId;
private final List<TicketSoldDTO> soldDtoList;
public TicketSoldResponse toResponse() {
return new TicketSoldResponse(paymentId, soldDtoList);
}
}

View File

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

View File

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

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,29 +1,5 @@
package com.ticketing.server.movie.service.interfaces;
import com.ticketing.server.global.validator.constraints.NotEmptyCollection;
import com.ticketing.server.movie.domain.Ticket;
import com.ticketing.server.movie.service.dto.TicketDTO;
import com.ticketing.server.movie.service.dto.TicketRefundDTO;
import com.ticketing.server.movie.service.dto.TicketsCancelDTO;
import com.ticketing.server.movie.service.dto.TicketsReservationDTO;
import com.ticketing.server.movie.service.dto.TicketsSoldDTO;
import com.ticketing.server.payment.service.dto.TicketDetailDTO;
import java.util.List;
import java.util.function.UnaryOperator;
import javax.validation.constraints.NotNull;
public interface TicketService {
List<TicketDTO> getTickets(@NotNull Long movieTimeId);
List<TicketDetailDTO> findTicketsByPaymentId(@NotNull Long paymentId);
TicketsReservationDTO ticketReservation(@NotEmptyCollection List<Long> ticketIds);
TicketsSoldDTO ticketSold(@NotNull Long paymentId, @NotEmptyCollection List<Long> ticketIds);
TicketsCancelDTO ticketCancel(@NotEmptyCollection List<Long> ticketIds);
List<TicketRefundDTO> ticketsRefund(@NotNull Long paymentId, UnaryOperator<Ticket> refund);
}

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

View File

@@ -1,20 +0,0 @@
package com.ticketing.server.payment.api;
import feign.Logger;
import feign.Logger.Level;
import feign.codec.Encoder;
import org.springframework.context.annotation.Bean;
public class CoreFeignConfiguration {
@Bean
Logger.Level feignLoggerLevel() {
return Level.FULL;
}
@Bean
Encoder formEncoder() {
return new feign.form.FormEncoder();
}
}

View File

@@ -1,32 +0,0 @@
package com.ticketing.server.payment.api;
import static org.springframework.http.MediaType.APPLICATION_FORM_URLENCODED_VALUE;
import com.ticketing.server.payment.api.dto.requset.KakaoPayApproveRequest;
import com.ticketing.server.payment.api.dto.requset.KakaoPayCancelRequest;
import com.ticketing.server.payment.api.dto.requset.KakaoPayReadyRequest;
import com.ticketing.server.payment.api.dto.response.KakaoPayApproveResponse;
import com.ticketing.server.payment.api.dto.response.KakaoPayCancelResponse;
import com.ticketing.server.payment.api.dto.response.KakaoPayReadyResponse;
import feign.Headers;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestHeader;
@FeignClient(name = "kakaoPay", url = "https://kapi.kakao.com/v1", path = "/payment",
configuration = CoreFeignConfiguration.class)
public interface KakaoPayClient {
@PostMapping(value = "/ready", consumes = APPLICATION_FORM_URLENCODED_VALUE)
@Headers("Content-Type: application/x-www-form-urlencoded;charset=utf-8")
KakaoPayReadyResponse ready(@RequestHeader(value = "Authorization") String authorization, KakaoPayReadyRequest request);
@PostMapping(value = "/approve", consumes = APPLICATION_FORM_URLENCODED_VALUE)
@Headers("Content-Type: application/x-www-form-urlencoded;charset=utf-8")
KakaoPayApproveResponse approve(@RequestHeader(value = "Authorization") String authorization, KakaoPayApproveRequest request);
@PostMapping(value = "/cancel", consumes = APPLICATION_FORM_URLENCODED_VALUE)
@Headers("Content-Type: application/x-www-form-urlencoded;charset=utf-8")
KakaoPayCancelResponse cancel(@RequestHeader(value = "Authorization") String authorization, KakaoPayCancelRequest request);
}

View File

@@ -1,40 +0,0 @@
package com.ticketing.server.payment.api;
import com.ticketing.server.global.factory.YamlPropertySourceFactory;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.ConstructorBinding;
import org.springframework.context.annotation.PropertySource;
@Getter
@RequiredArgsConstructor
@ConstructorBinding
@ConfigurationProperties(value = "api.kakao.pay")
@PropertySource(value = "classpath:application.yml", factory = YamlPropertySourceFactory.class)
public class KakaoPayProperties {
private final String url;
private final String approval;
private final String cancel;
private final String fail;
private final String prefix;
private final String key;
public String getApprovalUrl() {
return url + approval;
}
public String getCancelUrl() {
return url + cancel;
}
public String getFailUrl() {
return url + fail;
}
public String getAuthorization() {
return prefix + " " + key;
}
}

View File

@@ -1,28 +0,0 @@
package com.ticketing.server.payment.api;
import com.ticketing.server.movie.application.request.TicketCancelRequest;
import com.ticketing.server.movie.application.request.TicketReservationRequest;
import com.ticketing.server.movie.application.request.TicketSoldRequest;
import com.ticketing.server.movie.application.response.TicketCancelResponse;
import com.ticketing.server.movie.application.response.TicketDetailsResponse;
import com.ticketing.server.movie.application.response.TicketReservationResponse;
import com.ticketing.server.movie.application.response.TicketSoldResponse;
import com.ticketing.server.movie.service.dto.TicketsRefundResponse;
import com.ticketing.server.payment.api.impl.TicketsRefundRequest;
import java.time.LocalDateTime;
import javax.validation.constraints.NotNull;
public interface MovieClient {
TicketDetailsResponse getTicketsByPaymentId(@NotNull Long paymentId);
TicketReservationResponse ticketReservation(@NotNull TicketReservationRequest request);
TicketSoldResponse ticketSold(@NotNull TicketSoldRequest request);
TicketCancelResponse ticketCancel(@NotNull TicketCancelRequest request);
TicketsRefundResponse ticketRefundByDateTime(TicketsRefundRequest request, LocalDateTime dateTime);
TicketsRefundResponse ticketRefund(TicketsRefundRequest request);
}

View File

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

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