Feature/member

build.gradle

@@ -4,25 +4,52 @@ plugins {
     id 'io.spring.dependency-management' version '1.1.6'
 }
 
-group = 'co.kr.ticketing'
-version = '0.0.1-SNAPSHOT'
+allprojects {
+    apply plugin: 'java'
+    apply plugin: 'org.springframework.boot'
+    apply plugin: 'io.spring.dependency-management'
 
-java {
-    toolchain {
-        languageVersion = JavaLanguageVersion.of(17)
+    group = 'co.kr.ticketing'
+    version = '0.0.1-SNAPSHOT'
+
+    sourceCompatibility = '17'
+
+    configurations {
+        compileOnly {
+            extendsFrom annotationProcessor
+        }
     }
-}
 
-repositories {
-    mavenCentral()
-}
+    dependencies {
+        implementation 'org.springframework.boot:spring-boot-starter'
+        implementation 'org.springframework.boot:spring-boot-starter-web'
 
-dependencies {
-    implementation 'org.springframework.boot:spring-boot-starter-web'
-    testImplementation 'org.springframework.boot:spring-boot-starter-test'
-    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+        compileOnly 'org.projectlombok:lombok'
+        annotationProcessor 'org.projectlombok:lombok'
+        annotationProcessor 'org.springframework.boot:spring-boot-configuration-processor'
+
+        testImplementation 'org.springframework.boot:spring-boot-starter-test'
+        testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+    }
+
+    repositories {
+        mavenCentral()
+    }
 }
 
 tasks.named('test') {
     useJUnitPlatform()
 }
+
+
+jar {
+    enabled = false
+}
+
+bootJar {
+    enabled = false
+}
+
+build {
+    enabled = false
+}

member/build.gradle

@@ -0,0 +1,28 @@
+dependencies {
+    // database
+    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
+    implementation 'com.mysql:mysql-connector-j'
+
+    //encryption
+    implementation 'com.google.guava:guava:31.1-jre'
+
+    // validator
+    implementation 'org.springframework.boot:spring-boot-starter-validation'
+
+    //jwt
+    implementation 'io.jsonwebtoken:jjwt:0.9.1'
+    implementation 'com.sun.xml.bind:jaxb-impl:4.0.1'
+    implementation 'com.sun.xml.bind:jaxb-core:4.0.1'
+    implementation 'javax.xml.bind:jaxb-api:2.4.0-b180830.0359'
+}
+
+bootJar {
+    archivesBaseName = 'Admin'
+    archiveFileName = 'admin.jar'
+    destinationDirectory = file(project.rootProject.projectDir)
+    enabled = true
+}
+
+jar {
+    enabled = false
+}

member/src/main/java/co/kr/ticketing/member/MemberApplication.java

@@ -0,0 +1,15 @@
+package co.kr.ticketing.member;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
+
+@EnableJpaAuditing
+@SpringBootApplication
+public class MemberApplication {
+
+	public static void main(String[] args) {
+		SpringApplication.run(MemberApplication.class, args);
+	}
+
+}

member/src/main/java/co/kr/ticketing/member/auth/aop/AuthAspect.java

@@ -0,0 +1,47 @@
+package co.kr.ticketing.member.auth.aop;
+
+import java.util.Arrays;
+
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.springframework.stereotype.Component;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+import co.kr.ticketing.member.auth.config.AuthConfig;
+import co.kr.ticketing.member.auth.util.TokenUtil;
+import co.kr.ticketing.member.exception.UnAuthorized;
+import jakarta.servlet.http.Cookie;
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Aspect
+@Component
+@RequiredArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+public class AuthAspect {
+	TokenUtil tokenUtil;
+
+	@Before("@annotation(LoginCheck)")
+	public void loginCheck(JoinPoint jp) {
+		String token = getToken();
+		if (!tokenUtil.isValidToken(token)) {
+			throw new UnAuthorized();
+		}
+	}
+
+	private String getToken() {
+		Cookie[] cookies = ((ServletRequestAttributes)(RequestContextHolder.currentRequestAttributes())).getRequest()
+			.getCookies();
+
+		return cookies == null ? "" : Arrays.stream(cookies)
+			.filter(cookie -> cookie.getName().equals(AuthConfig.LOGIN_COOKIE_NAME))
+			.findAny()
+			.orElseThrow(UnAuthorized::new)
+			.getValue();
+	}
+}

member/src/main/java/co/kr/ticketing/member/auth/aop/LoginCheck.java

@@ -0,0 +1,11 @@
+package co.kr.ticketing.member.auth.aop;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface LoginCheck {
+}

member/src/main/java/co/kr/ticketing/member/auth/config/AuthConfig.java

@@ -0,0 +1,11 @@
+package co.kr.ticketing.member.auth.config;
+
+import lombok.experimental.UtilityClass;
+
+@UtilityClass
+public class AuthConfig {
+	public static String SECRET_KEY = "test_secret_key";
+	public static String PHONE_NUMBER = "phoneNumber";
+	public static int TOKEN_VALID_TIME = 86400;
+	public static String LOGIN_COOKIE_NAME = "token";
+}

member/src/main/java/co/kr/ticketing/member/auth/util/JwtUtil.java

@@ -0,0 +1,76 @@
+package co.kr.ticketing.member.auth.util;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.springframework.stereotype.Component;
+
+import co.kr.ticketing.member.auth.config.AuthConfig;
+import io.jsonwebtoken.JwtException;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.SignatureAlgorithm;
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+
+@Component
+@RequiredArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+public class JwtUtil {
+
+	public String generateJwt(Map<String, Object> valueMap, int expireSeconds) {
+		return generateToken(valueMap, expireSeconds, AuthConfig.SECRET_KEY);
+	}
+
+	public boolean isValidJwt(String jwt) {
+		if (jwt.isEmpty()) {
+			return false;
+		}
+
+		try {
+			Jwts.parser()
+				.setSigningKey(AuthConfig.SECRET_KEY.getBytes())
+				.parseClaimsJws(jwt)
+				.getBody();
+		} catch (JwtException e) {
+			return false;
+		}
+
+		return true;
+	}
+
+	private String generateToken(Map<String, Object> valueMap, int expireSeconds, String secretKey) {
+		Map<String, Object> headers = new HashMap<>();
+		headers.put("typ", "JWT");
+		headers.put("alg", "HS256");
+
+		Map<String, Object> payload = new HashMap<>();
+		payload.putAll(valueMap);
+
+		return Jwts.builder()
+			.setHeader(headers)
+			.setClaims(payload)
+			.setIssuedAt(
+				Date.from(
+					ZonedDateTime.now().toInstant()
+				))
+			.setExpiration(
+				getDate(expireSeconds)
+			)
+			.signWith(SignatureAlgorithm.HS256, secretKey.getBytes()).compact();
+	}
+
+	private Date getDate(int seconds) {
+		LocalDateTime localDateTime = LocalDateTime.now().plusSeconds(seconds);
+		return Date.from(
+			localDateTime.atZone(
+					ZoneId.systemDefault()
+				)
+				.toInstant()
+		);
+	}
+}

member/src/main/java/co/kr/ticketing/member/auth/util/TokenUtil.java

@@ -0,0 +1,30 @@
+package co.kr.ticketing.member.auth.util;
+
+import java.util.Map;
+
+import org.springframework.stereotype.Component;
+
+import co.kr.ticketing.member.auth.config.AuthConfig;
+import co.kr.ticketing.member.domain.model.Member;
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+
+@Component
+@RequiredArgsConstructor(access = AccessLevel.PROTECTED)
+@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+public class TokenUtil {
+	JwtUtil jwtUtil;
+
+	public String generateToken(Member member) {
+		Map<String, Object> payload = Map.of(
+			AuthConfig.PHONE_NUMBER, member.getPhoneNumber()
+		);
+
+		return jwtUtil.generateJwt(payload, AuthConfig.TOKEN_VALID_TIME);
+	}
+
+	public boolean isValidToken(String token) {
+		return jwtUtil.isValidJwt(token);
+	}
+}

member/src/main/java/co/kr/ticketing/member/controller/MemberController.java

@@ -0,0 +1,82 @@
+package co.kr.ticketing.member.controller;
+
+import org.springframework.http.ResponseCookie;
+import org.springframework.validation.annotation.Validated;
+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;
+
+import co.kr.ticketing.member.auth.aop.LoginCheck;
+import co.kr.ticketing.member.auth.config.AuthConfig;
+import co.kr.ticketing.member.auth.util.TokenUtil;
+import co.kr.ticketing.member.controller.request.LoginRequest;
+import co.kr.ticketing.member.controller.request.SignUpRequest;
+import co.kr.ticketing.member.domain.model.Member;
+import co.kr.ticketing.member.usecase.LoginUseCase;
+import co.kr.ticketing.member.usecase.SignUpUseCase;
+import co.kr.ticketing.member.util.CookieUtil;
+import co.kr.ticketing.member.util.dto.CookieDto;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.validation.Valid;
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+
+@Validated
+@RestController
+@RequestMapping(value = "/members")
+@RequiredArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+public class MemberController {
+	CookieUtil cookieUtil;
+	TokenUtil tokenUtil;
+	SignUpUseCase signupUseCase;
+	LoginUseCase loginUseCase;
+
+	@PostMapping
+	public void SignUp(@RequestBody @Valid SignUpRequest request) {
+		signupUseCase.execute(request);
+	}
+
+	@PostMapping("/login")
+	public void Login(@RequestBody @Valid LoginRequest request, HttpServletResponse response) {
+		Member member = loginUseCase.execute(request);
+
+		ResponseCookie responseCookie = createLoginTokenCookie(member);
+
+		response.addHeader("Set-Cookie", responseCookie.toString());
+	}
+
+	@LoginCheck
+	@PostMapping("/logout")
+	public void Logout(HttpServletResponse response) {
+		ResponseCookie responseCookie = invalidLoginTokenCookie();
+
+		response.addHeader("Set-Cookie", responseCookie.toString());
+	}
+
+	private ResponseCookie createLoginTokenCookie(Member member) {
+		String loginToken = tokenUtil.generateToken(member);
+
+		return cookieUtil.createTokenCookie(CookieDto.builder()
+			.name(AuthConfig.LOGIN_COOKIE_NAME)
+			.value(loginToken)
+			.isEncode(true)
+			.httpOnly(true)
+			.maxAge(AuthConfig.TOKEN_VALID_TIME)
+			.build()
+		);
+	}
+
+	private ResponseCookie invalidLoginTokenCookie() {
+		return cookieUtil.createTokenCookie(CookieDto.builder()
+			.name(AuthConfig.LOGIN_COOKIE_NAME)
+			.value(null)
+			.isEncode(false)
+			.httpOnly(true)
+			.maxAge(0)
+			.build()
+		);
+	}
+}

member/src/main/java/co/kr/ticketing/member/controller/request/LoginRequest.java

@@ -0,0 +1,11 @@
+package co.kr.ticketing.member.controller.request;
+
+import jakarta.validation.constraints.NotBlank;
+
+public record LoginRequest(
+	@NotBlank
+	String phoneNumber,
+	@NotBlank
+	String password
+) {
+}