[그리디] 서현진 Spring JPA (1차) 4,5,6 단계 미션 제출합니다.

build.gradle

@@ -15,16 +15,20 @@ repositories {
 dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-web'
     implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
-    implementation 'org.springframework.boot:spring-boot-starter-jdbc'
+    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
 
     implementation 'dev.akkinoc.spring.boot:logback-access-spring-boot-starter:4.0.0'
-
     implementation 'io.jsonwebtoken:jjwt-api:0.11.2'
     implementation 'io.jsonwebtoken:jjwt-impl:0.11.2'
     implementation 'io.jsonwebtoken:jjwt-gson:0.11.2'
 
-    testImplementation 'org.springframework.boot:spring-boot-starter-test'
+    testImplementation 'org.springframework.boot:spring-boot-starter-data-jpa'
     testImplementation 'io.rest-assured:rest-assured:5.3.1'
+    testImplementation 'com.h2database:h2'
+    testImplementation 'org.springframework.boot:spring-boot-starter-test'
+
+
+
 
     runtimeOnly 'com.h2database:h2'
 }

src/main/java/roomescape/advice/ErrorResponse.java

@@ -0,0 +1,4 @@
+package roomescape.advice;
+
+public record ErrorResponse(String message) {
+}

src/main/java/roomescape/advice/GlobalExceptionHandler.java

@@ -0,0 +1,28 @@
+package roomescape.advice;
+
+import org.springframework.data.crossstore.ChangeSetPersister;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+
+@ControllerAdvice
+public class GlobalExceptionHandler {
+
+    @ExceptionHandler(IllegalArgumentException.class)
+    public ResponseEntity<ErrorResponse> handleIllegalArgumentException(IllegalArgumentException e) {
+        return ResponseEntity.badRequest()
+                .body(new ErrorResponse(e.getMessage()));
+    }
+
+    @ExceptionHandler(ChangeSetPersister.NotFoundException.class)
+    public ResponseEntity<ErrorResponse> handleNotFoundException(RuntimeException e) {
+        return ResponseEntity.status(404)
+                .body(new ErrorResponse(e.getMessage()));
+    }
+
+    @ExceptionHandler(Exception.class)
+    public ResponseEntity<ErrorResponse> handleException(Exception e) {
+        return ResponseEntity.internalServerError()
+                .body(new ErrorResponse("오류가 발생했습니다."));
+    }
+}

src/main/java/roomescape/auth/AuthMember.java

@@ -0,0 +1,11 @@
+package roomescape.auth;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AuthMember {
+}

src/main/java/roomescape/infrastructure/DataInitializer.java

@@ -0,0 +1,106 @@
+package roomescape.infrastructure;
+
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import roomescape.member.Member;
+import roomescape.member.MemberRepository;
+import roomescape.theme.Theme;
+import roomescape.theme.ThemeRepository;
+import roomescape.time.Time;
+import roomescape.time.TimeRepository;
+import roomescape.reservation.Reservation;
+import roomescape.reservation.ReservationRepository;
+
+@Component
+public class DataInitializer implements CommandLineRunner {
+
+    private final MemberRepository memberRepository;
+    private final ThemeRepository themeRepository;
+    private final TimeRepository timeRepository;
+    private final ReservationRepository reservationRepository;
+    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(DataInitializer.class);
+
+    public DataInitializer(
+            MemberRepository memberRepository,
+            ThemeRepository themeRepository,
+            TimeRepository timeRepository,
+            ReservationRepository reservationRepository
+    ) {
+        this.memberRepository = memberRepository;
+        this.themeRepository = themeRepository;
+        this.timeRepository = timeRepository;
+        this.reservationRepository = reservationRepository;
+    }
+
+    @Override
+    @Transactional
+    public void run(String... args) throws Exception {
+        // 1. 관리자 계정 생성
+        if (memberRepository.findByEmail("admin").isEmpty()) {
+            Member admin = new Member("admin", "admin", "admin", "ADMIN");
+            Member user = new Member("user", "user", "user", "USER");
+            memberRepository.save(admin);
+            memberRepository.save(user);
+            log.info("관리자 계정이 생성되었습니다.");
+        }
+
+        // 2. 테마 데이터 생성
+        if (themeRepository.count() == 0) {
+            Theme theme1 = new Theme("테마1", "테마1입니다.");
+            Theme theme2 = new Theme("테마2", "테마2입니다.");
+            Theme theme3 = new Theme("테마3", "테마3입니다.");
+
+            themeRepository.save(theme1);
+            themeRepository.save(theme2);
+            themeRepository.save(theme3);
+            log.info("테마 데이터가 생성되었습니다.");
+        }
+
+        // 3. 시간 데이터 생성
+        if (timeRepository.count() == 0) {
+            Time time1 = new Time("10:00");
+            Time time2 = new Time("12:00");
+            Time time3 = new Time("14:00");
+            Time time4 = new Time("16:00");
+            Time time5 = new Time("18:00");
+            Time time6 = new Time("20:00");
+
+            timeRepository.save(time1);
+            timeRepository.save(time2);
+            timeRepository.save(time3);
+            timeRepository.save(time4);
+            timeRepository.save(time5);
+            timeRepository.save(time6);
+            log.info("시간 데이터가 생성되었습니다.");
+        }
+
+        if (reservationRepository.count() == 0) {
+            Member admin = memberRepository.findByEmail("admin")
+                    .orElseThrow(() -> new RuntimeException("Admin not found"));
+
+            Time time1 = timeRepository.findById(1L).orElseThrow();
+            Time time2 = timeRepository.findById(2L).orElseThrow();
+            Time time3 = timeRepository.findById(3L).orElseThrow();
+
+            Theme theme1 = themeRepository.findById(1L).orElseThrow();
+            Theme theme2 = themeRepository.findById(2L).orElseThrow();
+            Theme theme3 = themeRepository.findById(3L).orElseThrow();
+
+            Reservation reservation1 = new Reservation("", "2024-03-01", time1, theme1, admin);
+            Reservation reservation2 = new Reservation("", "2024-03-01", time2, theme2, admin);
+            Reservation reservation3 = new Reservation("", "2024-03-01", time3, theme3, admin);
+
+            reservationRepository.save(reservation1);
+            reservationRepository.save(reservation2);
+            reservationRepository.save(reservation3);
+
+            Reservation reservation4 = new Reservation("브라운", "2024-03-01", time1, theme2);
+
+            reservationRepository.save(reservation4);
+            log.info("예약 데이터가 생성되었습니다.");
+        }
+
+        log.info("초기 데이터 로딩이 완료되었습니다.");
+    }
+}

src/main/java/roomescape/infrastructure/JwtTokenProvider.java

@@ -0,0 +1,42 @@
+package roomescape.infrastructure;
+
+import io.jsonwebtoken.*;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+
+@Component
+public class JwtTokenProvider {
+    @Value("${security.jwt.token.secret-key:this-is-a-sample-secret-key-at-least-32-bytes-long}")
+    private String secretKey;
+    @Value("${security.jwt.token.expire-length:3600000}")
+    private long validityInMilliseconds;
+
+    public String createToken(String payload) {
+        Claims claims = Jwts.claims().setSubject(payload);
+        Date now = new Date();
+        Date validity = new Date(now.getTime() + validityInMilliseconds);
+
+        return Jwts.builder()
+                .setClaims(claims)
+                .setIssuedAt(now)
+                .setExpiration(validity)
+                .signWith(SignatureAlgorithm.HS256, secretKey)
+                .compact();
+    }
+
+    public String getPayload(String token) {
+        return Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token).getBody().getSubject();
+    }
+
+    public boolean validateToken(String token) {
+        try {
+            Jws<Claims> claims = Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token);
+            return !claims.getBody().getExpiration().before(new Date());
+        } catch (JwtException | IllegalArgumentException e) {
+            return false;
+        }
+    }
+}
+

src/main/java/roomescape/member/Member.java

@@ -1,12 +1,32 @@
 package roomescape.member;
 
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "member")
 public class Member {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
+
+    @Column(nullable = false)
     private String name;
+
+    @Column(nullable = false, unique = true)
     private String email;
+
+    @Column(nullable = false)
     private String password;
+
+    @Column(nullable = false)
     private String role;
 
+    @Column(name = "deleted")
+    private boolean deleted = false;
+
+    protected Member() {
+    }
+
     public Member(Long id, String name, String email, String role) {
         this.id = id;
         this.name = name;
@@ -40,4 +60,8 @@ public String getPassword() {
     public String getRole() {
         return role;
     }
+
+    public void delete() {
+        this.deleted = true;
+    }
 }

src/main/java/roomescape/member/MemberController.java

@@ -1,13 +1,13 @@
 package roomescape.member;
 
 import jakarta.servlet.http.Cookie;
-import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
 import org.springframework.http.ResponseEntity;
 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.RestController;
+import roomescape.auth.AuthMember;
 
 import java.net.URI;
 
@@ -19,6 +19,34 @@ public MemberController(MemberService memberService) {
         this.memberService = memberService;
     }
 
+    @PostMapping("/login")
+    public ResponseEntity<Void> login(
+            @RequestBody MemberRequest memberRequest,
+            HttpServletResponse response) {
+
+        String tokenValue = memberService.login(memberRequest);
+
+        Cookie cookie = new Cookie("token", tokenValue);
+        cookie.setHttpOnly(true);
+        cookie.setPath("/");
+        cookie.setMaxAge(3600);
+        response.addCookie(cookie);
+
+        return ResponseEntity.ok()
+                .header("Keep-Alive", "timeout=60")
+                .build();
+    }
+
+    @GetMapping("/login/check")
+    public ResponseEntity<MemberResponse> check(
+            @AuthMember Member member
+    ) {
+        return ResponseEntity.ok()
+                .header("Connection", "keep-alive")
+                .header("Keep-Alive", "timeout=60")
+                .body(new MemberResponse(null, member.getName(), null));
+    }
+
     @PostMapping("/members")
     public ResponseEntity createMember(@RequestBody MemberRequest memberRequest) {
         MemberResponse member = memberService.createMember(memberRequest);

src/main/java/roomescape/member/MemberDao.java

@@ -40,16 +40,16 @@ public Member findByEmailAndPassword(String email, String password) {
         );
     }
 
-    public Member findByName(String name) {
+    public Member findByEmail(String email) {
         return jdbcTemplate.queryForObject(
-                "SELECT id, name, email, role FROM member WHERE name = ?",
+                "SELECT id, name, email, role FROM member WHERE email = ?",
                 (rs, rowNum) -> new Member(
                         rs.getLong("id"),
                         rs.getString("name"),
                         rs.getString("email"),
                         rs.getString("role")
                 ),
-                name
+                email
         );
     }
-}
+}

src/main/java/roomescape/member/MemberRepository.java

@@ -0,0 +1,55 @@
+package roomescape.member;
+
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.NoResultException;
+import jakarta.persistence.PersistenceContext;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Optional;
+
+@Repository
+@Transactional(readOnly = true)
+public class MemberRepository {
+
+    @PersistenceContext
+    private EntityManager em;
+
+    @Transactional
+    public Member save(Member member) {
+        em.persist(member);
+        return member;
+    }
+
+    public Optional<Member> findByEmailAndPassword(String email, String password) {
+        try {
+            Member member = em.createQuery(
+                            "SELECT m FROM Member m WHERE m.email = :email AND m.password = :password",
+                            Member.class)
+                    .setParameter("email", email)
+                    .setParameter("password", password)
+                    .getSingleResult();
+            return Optional.of(member);
+        } catch (NoResultException e) {
+            return Optional.empty();
+        }
+    }
+
+    public Optional<Member> findByEmail(String email) {
+        try {
+            Member member = em.createQuery(
+                            "SELECT m FROM Member m WHERE m.email = :email",
+                            Member.class)
+                    .setParameter("email", email)
+                    .getSingleResult();
+            return Optional.of(member);
+        } catch (NoResultException e) {
+            return Optional.empty();
+        }
+    }
+
+    public Optional<Member> findById(Long id) {
+        Member member = em.find(Member.class, id);
+        return Optional.ofNullable(member);
+    }
+}

src/main/java/roomescape/member/MemberRequest.java

@@ -16,4 +16,4 @@ public String getEmail() {
     public String getPassword() {
         return password;
     }
-}
+}