Merge pull request #19 from 29sungdong/feat/walk

[feat] 장소 산책 API 구현

src/main/java/sungdong29/backend/BackendApplication.java

@@ -3,8 +3,10 @@
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
+import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
 
 @SpringBootApplication(exclude = {SecurityAutoConfiguration.class})
+@EnableJpaAuditing
 public class BackendApplication {
 
 	public static void main(String[] args) {

src/main/java/sungdong29/backend/domain/badge/domain/Badge.java

@@ -24,6 +24,5 @@ public class Badge {
 
     @NotNull
     @Column
-    @Size(max = 100)
-    private String name;
+    private String imageUrl;
 }

src/main/java/sungdong29/backend/domain/badge/domain/UserBadge.java

@@ -1,10 +1,7 @@
 package sungdong29.backend.domain.badge.domain;
 
 import jakarta.persistence.*;
-import lombok.AccessLevel;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
+import lombok.*;
 import sungdong29.backend.domain.user.domain.User;
 
 @Entity
@@ -24,6 +21,20 @@ public class UserBadge {
     @JoinColumn(name="badge_id")
     private Badge badge;
 
-    private boolean isAchieved;
-    private Integer progress;
+    private String name;
+
+    @Builder
+    private UserBadge(User user, Badge badge, String name) {
+        this.user=user;
+        this.badge=badge;
+        this.name=name;
+    }
+
+    public static UserBadge of(User user, Badge badge, String name) {
+        return UserBadge.builder()
+                .user(user)
+                .badge(badge)
+                .name(name)
+                .build();
+    }
 }

src/main/java/sungdong29/backend/domain/badge/dto/response/BadgeResponseDTO.java

@@ -1,12 +1,32 @@
 package sungdong29.backend.domain.badge.dto.response;
 
+import lombok.Builder;
 import lombok.Getter;
-import lombok.Setter;
+import sungdong29.backend.domain.badge.domain.Badge;
+
+import java.util.List;
 
 @Getter
-@Setter
 public class BadgeResponseDTO {
-    Long id;
-    String name;
-    String category;
+    private Long id;
+    private String category;
+    private String imageUrl;
+    private List<UserBadgeResponseDTO> achievedBadges;
+
+    @Builder
+    private BadgeResponseDTO(Long id, String category, String imageUrl, List<UserBadgeResponseDTO> achievedBadges) {
+        this.id= id;
+        this.category=category;
+        this.imageUrl= imageUrl;
+        this.achievedBadges=achievedBadges;
+    }
+
+    public static BadgeResponseDTO of(Badge badge, List<UserBadgeResponseDTO> userBadges) {
+        return BadgeResponseDTO.builder()
+                .id(badge.getId())
+                .category(badge.getCategory())
+                .imageUrl(badge.getImageUrl())
+                .achievedBadges(userBadges)
+                .build();
+    }
 }

src/main/java/sungdong29/backend/domain/badge/dto/response/BadgesResponseDTO.java

@@ -1,28 +1,22 @@
 package sungdong29.backend.domain.badge.dto.response;
 
+import lombok.Builder;
 import lombok.Getter;
-import lombok.Setter;
 
 import java.util.List;
-import java.util.stream.Collectors;
 
 @Getter
-@Setter
 public class BadgesResponseDTO {
-    private List<GroupedBadgeDTO> groupedBadges;
+    private List<BadgeResponseDTO> badges;
 
-    public static BadgesResponseDTO from(List<BadgeResponseDTO> badgeResponseDTOS) {
-        BadgesResponseDTO responseDTO = new BadgesResponseDTO();
-        responseDTO.groupedBadges = groupBadgesByCategory(badgeResponseDTOS);
-        return responseDTO;
+    @Builder
+    private BadgesResponseDTO(List<BadgeResponseDTO> badges) {
+        this.badges = badges;
     }
 
-    private static List<GroupedBadgeDTO> groupBadgesByCategory(List<BadgeResponseDTO> badgeResponseDTOS) {
-        return badgeResponseDTOS.stream()
-                .collect(Collectors.groupingBy(BadgeResponseDTO::getCategory))
-                .entrySet()
-                .stream()
-                .map(category -> new GroupedBadgeDTO(category.getKey(), category.getValue()))
-                .collect(Collectors.toList());
+    public static BadgesResponseDTO from(List<BadgeResponseDTO> badgeResponseDTOS) {
+        return BadgesResponseDTO.builder()
+                .badges(badgeResponseDTOS)
+                .build();
     }
 }

src/main/java/sungdong29/backend/domain/badge/dto/response/UserBadgeResponseDTO.java

@@ -0,0 +1,24 @@
+package sungdong29.backend.domain.badge.dto.response;
+
+import lombok.Builder;
+import lombok.Getter;
+import sungdong29.backend.domain.badge.domain.UserBadge;
+
+@Getter
+public class UserBadgeResponseDTO {
+    private Long id;
+    private String name;
+
+    @Builder
+    private UserBadgeResponseDTO(Long id, String name) {
+        this.id=id;
+        this.name= name;
+    }
+
+    public static UserBadgeResponseDTO from(UserBadge userBadge) {
+        return UserBadgeResponseDTO.builder()
+                .id(userBadge.getId())
+                .name(userBadge.getName())
+                .build();
+    }
+}

src/main/java/sungdong29/backend/domain/badge/repository/BadgeRepository.java

@@ -2,10 +2,9 @@
 
 import org.springframework.data.jpa.repository.JpaRepository;
 import sungdong29.backend.domain.badge.domain.Badge;
-import sungdong29.backend.domain.badge.domain.UserBadge;
 
-import java.util.List;
+import java.util.Optional;
 
-public interface BadgeRepository extends JpaRepository<UserBadge, Long> {
-    List<UserBadge> findByUserIdAndIsAchievedTrue(Long userId);
+public interface BadgeRepository extends JpaRepository<Badge, Long> {
+    Optional<Badge> findByCategory(String category);
 }

src/main/java/sungdong29/backend/domain/badge/repository/UserBadgeRepository.java

@@ -0,0 +1,14 @@
+package sungdong29.backend.domain.badge.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import sungdong29.backend.domain.badge.domain.UserBadge;
+import sungdong29.backend.domain.user.domain.User;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface UserBadgeRepository extends JpaRepository<UserBadge, Long> {
+    List<UserBadge> findByUserId(Long userId);
+
+    Optional<UserBadge> findByUserAndName(User user, String name);
+}

src/main/java/sungdong29/backend/domain/badge/service/BadgeService.java

@@ -3,25 +3,32 @@
 import lombok.RequiredArgsConstructor;
 import org.modelmapper.ModelMapper;
 import org.springframework.stereotype.Service;
+import sungdong29.backend.domain.badge.domain.Badge;
 import sungdong29.backend.domain.badge.domain.UserBadge;
 import sungdong29.backend.domain.badge.dto.response.BadgeResponseDTO;
 import sungdong29.backend.domain.badge.dto.response.BadgesResponseDTO;
+import sungdong29.backend.domain.badge.dto.response.UserBadgeResponseDTO;
 import sungdong29.backend.domain.badge.repository.BadgeRepository;
+import sungdong29.backend.domain.badge.repository.UserBadgeRepository;
 
 import java.util.List;
 import java.util.stream.Collectors;
 
 @Service
 @RequiredArgsConstructor
 public class BadgeService {
-    private final BadgeRepository badgeRepository;
-    private final ModelMapper mapper;
+    private final UserBadgeRepository userBadgeRepository;
 
     public BadgesResponseDTO findUserBadges(Long userId) {
-        List<UserBadge> userBadges = badgeRepository.findByUserIdAndIsAchievedTrue(userId);
+        List<UserBadge> userBadges = userBadgeRepository.findByUserId(userId);
         List<BadgeResponseDTO> badgeResponseDTOS = userBadges
                 .stream()
-                .map(userBadge -> mapper.map(userBadge.getBadge(), BadgeResponseDTO.class))
+                .collect(Collectors.groupingBy(UserBadge::getBadge))
+                .entrySet().stream()
+                .map(entry -> BadgeResponseDTO.of(entry.getKey(),
+                        entry.getValue().stream()
+                                .map(UserBadgeResponseDTO::from)
+                                .collect(Collectors.toList())))
                 .collect(Collectors.toList());
 
         return BadgesResponseDTO.from(badgeResponseDTOS);

src/main/java/sungdong29/backend/domain/subPlace/repository/SubPlaceRepository.java

@@ -4,7 +4,6 @@
 import sungdong29.backend.domain.subPlace.domain.SubPlace;
 
 import java.util.List;
-import java.util.Optional;
 
 public interface SubPlaceRepository extends JpaRepository<SubPlace, Long> {
     List<SubPlace> findByPlaceId(Long place_id);

src/main/java/sungdong29/backend/domain/walk/WalkController.java

@@ -0,0 +1,32 @@
+package sungdong29.backend.domain.walk;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import sungdong29.backend.domain.place.dto.response.PlaceListResponseDTO;
+import sungdong29.backend.domain.walk.dto.request.WalkRecordRequestDTO;
+import sungdong29.backend.domain.walk.dto.response.WalkBadgeResponseDTO;
+import sungdong29.backend.domain.walk.service.WalkService;
+import sungdong29.backend.global.config.LoginUser;
+
+@Slf4j
+@RestController
+@RequiredArgsConstructor
+@RequestMapping
+@Tag(name = "Walk")
+public class WalkController {
+    private final WalkService walkService;
+
+    @Operation(summary = "산책 기록 저장")
+    @PostMapping(value = "places/{placeId}/walk")
+    public ResponseEntity<WalkBadgeResponseDTO> createWalkRecord(
+            @LoginUser Long userId,
+            @PathVariable Long placeId,
+            @RequestBody WalkRecordRequestDTO walkRecordRequestDTO) {
+        WalkBadgeResponseDTO walkBadgeResponseDTO = walkService.createWalkRecord(userId, placeId, walkRecordRequestDTO);
+        return ResponseEntity.ok(walkBadgeResponseDTO);
+    }
+}

src/main/java/sungdong29/backend/domain/walk/domain/Walk.java

@@ -0,0 +1,51 @@
+package sungdong29.backend.domain.walk.domain;
+
+import jakarta.persistence.*;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+import sungdong29.backend.domain.place.domain.Place;
+import sungdong29.backend.domain.user.domain.User;
+
+import java.time.LocalDateTime;
+
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Entity
+@EntityListeners(AuditingEntityListener.class)
+public class Walk {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne
+    @JoinColumn(name="user_id")
+    private User user;
+
+    @ManyToOne
+    @JoinColumn(name="place_id")
+    private Place place;
+
+    @CreatedDate
+    private LocalDateTime createdAt;
+
+    private Integer steps;
+
+    @Builder
+    private Walk(User user, Place place, Integer steps) {
+        this.user=user;
+        this.place=place;
+        this.steps=steps;
+    }
+
+    public static Walk of(User user, Place place, Integer steps) {
+        return Walk.builder()
+                .user(user)
+                .place(place)
+                .steps(steps)
+                .build();
+    }
+}

src/main/java/sungdong29/backend/domain/walk/dto/request/WalkRecordRequestDTO.java

@@ -0,0 +1,8 @@
+package sungdong29.backend.domain.walk.dto.request;
+
+import lombok.Getter;
+
+@Getter
+public class WalkRecordRequestDTO {
+    private Integer steps;
+}

src/main/java/sungdong29/backend/domain/walk/dto/response/WalkBadgeResponseDTO.java

@@ -0,0 +1,26 @@
+package sungdong29.backend.domain.walk.dto.response;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+import sungdong29.backend.domain.badge.domain.Badge;
+import sungdong29.backend.domain.badge.domain.UserBadge;
+
+@Getter
+public class WalkBadgeResponseDTO {
+    Badge badge;
+    String name;
+
+    @Builder
+    private WalkBadgeResponseDTO(Badge badge, String name) {
+        this.badge = badge;
+        this.name = name;
+    }
+
+    public static WalkBadgeResponseDTO from(UserBadge userBadge) {
+        return WalkBadgeResponseDTO.builder()
+                .badge(userBadge.getBadge())
+                .name(userBadge.getName())
+                .build();
+    }
+}

src/main/java/sungdong29/backend/domain/walk/exception/BadgeErrorCode.java

@@ -0,0 +1,23 @@
+package sungdong29.backend.domain.walk.exception;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import org.springframework.http.HttpStatus;
+import sungdong29.backend.global.common.dto.ErrorReason;
+import sungdong29.backend.global.error.BaseErrorCode;
+
+import static org.springframework.http.HttpStatus.*;
+
+@Getter
+@AllArgsConstructor
+public enum BadgeErrorCode implements BaseErrorCode {
+    BADGE_NOT_FOUND(NOT_FOUND, "PLACE_404_1", "장소가 존재하지 않습니다.");
+    private HttpStatus status;
+    private String code;
+    private String reason;
+
+    @Override
+    public ErrorReason getErrorReason() {
+        return ErrorReason.of(status.value(), code, reason);
+    }
+}