스탬프 추가 기능 구현

src/docs/asciidoc/stamp.adoc

@@ -0,0 +1,5 @@
+=== 새로운 스탬프 추가
+==== 요청
+operation::stamp-controller-test/스탬프_생성을_요청하면_새로운_스탬프를_생성한다[snippets='http-request,request-headers,request-fields']
+==== 응답
+operation::stamp-controller-test/스탬프_생성을_요청하면_새로운_스탬프를_생성한다[snippets='http-response,response-fields']

src/main/java/com/backend/blooming/exception/ExceptionMessage.java

@@ -54,6 +54,13 @@ public enum ExceptionMessage {
     DELETE_GOAL_FORBIDDEN("골을 삭제할 권한이 없습니다."),
     UPDATE_GOAL_FORBIDDEN("골을 수정할 권한이 없습니다."),
     UPDATE_TEAMS_FORBIDDEN("골 참여자 목록은 비어있을 수 없습니다."),
+
+    // 스탬프
+    INVALID_STAMP_DAY("스탬프 날짜는 골 시작일 이전이거나 종료일 이후일 수 없습니다."),
+    INVALID_STAMP_DAY_FUTURE("오늘보다 이후의 스탬프는 추가할 수 없습니다."),
+    INVALID_STAMP_TO_CREATE("이미 해당 날짜의 스탬프가 존재합니다."),
+    CREATE_STAMP_FORBIDDEN("스탬프를 추가할 권한이 없습니다."),
+    INVALID_STAMP_MESSAGE("스탬프 인증 메시지는 비어있거나 50자 초과일 수 없습니다."),
 
     // 관리자 페이지
     INVALID_FRIEND_STATUS("잘못된 친구 상태입니다.");

src/main/java/com/backend/blooming/exception/GlobalExceptionHandler.java

@@ -12,6 +12,8 @@
 import com.backend.blooming.goal.application.exception.DeleteGoalForbiddenException;
 import com.backend.blooming.goal.application.exception.InvalidGoalException;
 import com.backend.blooming.goal.application.exception.NotFoundGoalException;
+import com.backend.blooming.stamp.application.exception.CreateStampForbiddenException;
+import com.backend.blooming.stamp.domain.exception.InvalidStampException;
 import com.backend.blooming.goal.application.exception.UpdateGoalForbiddenException;
 import com.backend.blooming.themecolor.domain.exception.UnsupportedThemeColorException;
 import com.backend.blooming.user.application.exception.NotFoundUserException;
@@ -205,4 +207,24 @@ public ResponseEntity<ExceptionResponse> handleAlreadyRegisterBlackListTokenExce
         return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                              .body(new ExceptionResponse(exception.getMessage()));
     }
+
+    @ExceptionHandler(InvalidStampException.class)
+    public ResponseEntity<ExceptionResponse> handleInvalidStampException(
+            final InvalidStampException exception
+    ) {
+        logger.warn(String.format(LOG_MESSAGE_FORMAT, exception.getClass().getSimpleName(), exception.getMessage()));
+
+        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
+                             .body(new ExceptionResponse(exception.getMessage()));
+    }
+
+    @ExceptionHandler(CreateStampForbiddenException.class)
+    public ResponseEntity<ExceptionResponse> handleCreateStampForbiddenException(
+            final CreateStampForbiddenException exception
+    ) {
+        logger.warn(String.format(LOG_MESSAGE_FORMAT, exception.getClass().getSimpleName(), exception.getMessage()));
+
+        return ResponseEntity.status(HttpStatus.FORBIDDEN)
+                             .body(new ExceptionResponse(exception.getMessage()));
+    }
 }

src/main/java/com/backend/blooming/goal/domain/GoalTerm.java

@@ -38,10 +38,8 @@ public GoalTerm(final LocalDate startDate, final LocalDate endDate) {
         this.endDate = endDate;
         this.days = getValidGoalDays(startDate, endDate);
     }
-
-    private void validateGoalDatePeriod(
-            final LocalDate startDate,
-            final LocalDate endDate) {
+
+    private void validateGoalDatePeriod(final LocalDate startDate, final LocalDate endDate) {
         final LocalDate nowDate = LocalDate.now();
 
         if (startDate.isBefore(nowDate)) {
@@ -54,10 +52,8 @@ private void validateGoalDatePeriod(
             throw new InvalidGoalException.InvalidInvalidGoalPeriod();
         }
     }
-
-    private long getValidGoalDays(
-            final LocalDate startDate,
-            final LocalDate endDate) {
+
+    private long getValidGoalDays(final LocalDate startDate, final LocalDate endDate) {
         final long goalDays = ChronoUnit.DAYS.between(startDate, endDate) + COUNT_GOAL_DAYS;
 
         if (goalDays < GOAL_DAYS_MINIMUM || goalDays > GOAL_DAYS_MAXIMUM) {

src/main/java/com/backend/blooming/goal/infrastructure/repository/GoalRepository.java

@@ -33,4 +33,13 @@ public interface GoalRepository extends JpaRepository<Goal, Long> {
             ORDER BY g.goalTerm.startDate DESC
             """)
     List<Goal> findAllByUserIdAndFinished(final Long userId, final LocalDate now);
+
+    @Query("""
+            SELECT g
+            FROM Goal g
+            JOIN FETCH g.teams.goalTeams gt
+            JOIN FETCH gt.user gtu
+            WHERE g.id = :goalId AND g.deleted = FALSE
+            """)
+    Optional<Goal> findByIdWithUserAndDeletedIsFalse(final Long goalId);
 }

src/main/java/com/backend/blooming/stamp/application/StampService.java

@@ -0,0 +1,78 @@
+package com.backend.blooming.stamp.application;
+
+import com.backend.blooming.goal.application.exception.NotFoundGoalException;
+import com.backend.blooming.goal.domain.Goal;
+import com.backend.blooming.goal.infrastructure.repository.GoalRepository;
+import com.backend.blooming.stamp.application.dto.CreateStampDto;
+import com.backend.blooming.stamp.application.dto.ReadStampDto;
+import com.backend.blooming.stamp.application.exception.CreateStampForbiddenException;
+import com.backend.blooming.stamp.domain.Stamp;
+import com.backend.blooming.stamp.domain.exception.InvalidStampException;
+import com.backend.blooming.stamp.infrastructure.repository.StampRepository;
+import com.backend.blooming.user.application.exception.NotFoundUserException;
+import com.backend.blooming.user.domain.User;
+import com.backend.blooming.user.infrastructure.repository.UserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+@Service
+@Transactional
+@RequiredArgsConstructor
+public class StampService {
+
+    private final GoalRepository goalRepository;
+    private final UserRepository userRepository;
+    private final StampRepository stampRepository;
+
+    public ReadStampDto createStamp(final CreateStampDto createStampDto) {
+        final Goal goal = getGoal(createStampDto.goalId());
+        final User user = getUser(createStampDto.userId());
+        validateUserInGoalTeams(goal, user.getId());
+        validateExistStamp(user.getId(), createStampDto.day());
+        final Stamp stamp = persistStamp(createStampDto, goal, user);
+
+        return ReadStampDto.from(stamp);
+    }
+
+    private Goal getGoal(final Long goalId) {
+        return goalRepository.findByIdWithUserAndDeletedIsFalse(goalId)
+                             .orElseThrow(NotFoundGoalException::new);
+    }
+
+    private User getUser(final Long userId) {
+        return userRepository.findByIdAndDeletedIsFalse(userId)
+                             .orElseThrow(NotFoundUserException::new);
+    }
+
+    private void validateUserInGoalTeams(final Goal goal, final Long userId) {
+        final List<Long> teamUserIds = goal.getTeams()
+                                           .getGoalTeams()
+                                           .stream()
+                                           .map(goalTeam -> goalTeam.getUser().getId())
+                                           .toList();
+        if (!teamUserIds.contains(userId)) {
+            throw new CreateStampForbiddenException();
+        }
+    }
+
+    private void validateExistStamp(final Long userId, final int day) {
+        final boolean isExistsStamp = stampRepository.existsByUserIdAndDayAndDeletedIsFalse(userId, day);
+        if (isExistsStamp) {
+            throw new InvalidStampException.InvalidStampToCreate();
+        }
+    }
+
+    private Stamp persistStamp(final CreateStampDto createStampDto, final Goal goal, final User user) {
+        final Stamp stamp = Stamp.builder()
+                                 .goal(goal)
+                                 .user(user)
+                                 .day(createStampDto.day())
+                                 .message(createStampDto.message())
+                                 .build();
+
+        return stampRepository.save(stamp);
+    }
+}

src/main/java/com/backend/blooming/stamp/application/dto/CreateStampDto.java

@@ -0,0 +1,20 @@
+package com.backend.blooming.stamp.application.dto;
+
+import com.backend.blooming.stamp.presentation.dto.request.CreateStampRequest;
+
+public record CreateStampDto(
+        Long goalId,
+        Long userId,
+        int day,
+        String message
+) {
+
+    public static CreateStampDto of(final CreateStampRequest request, final Long userId) {
+        return new CreateStampDto(
+                request.goalId(),
+                userId,
+                request.day(),
+                request.message()
+        );
+    }
+}

src/main/java/com/backend/blooming/stamp/application/dto/ReadStampDto.java

@@ -0,0 +1,18 @@
+package com.backend.blooming.stamp.application.dto;
+
+import com.backend.blooming.stamp.domain.Stamp;
+
+public record ReadStampDto(
+        Long goalId,
+        int day,
+        String message
+) {
+
+    public static ReadStampDto from(final Stamp stamp) {
+        return new ReadStampDto(
+                stamp.getGoal().getId(),
+                stamp.getDay(),
+                stamp.getMessage()
+        );
+    }
+}

src/main/java/com/backend/blooming/stamp/application/exception/CreateStampForbiddenException.java

@@ -0,0 +1,11 @@
+package com.backend.blooming.stamp.application.exception;
+
+import com.backend.blooming.exception.BloomingException;
+import com.backend.blooming.exception.ExceptionMessage;
+
+public class CreateStampForbiddenException extends BloomingException {
+
+    public CreateStampForbiddenException() {
+        super(ExceptionMessage.CREATE_STAMP_FORBIDDEN);
+    }
+}

src/main/java/com/backend/blooming/stamp/domain/Stamp.java

@@ -0,0 +1,96 @@
+package com.backend.blooming.stamp.domain;
+
+import com.backend.blooming.common.entity.BaseTimeEntity;
+import com.backend.blooming.goal.domain.Goal;
+import com.backend.blooming.stamp.domain.exception.InvalidStampException;
+import com.backend.blooming.user.domain.User;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.ForeignKey;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+
+import java.time.LocalDate;
+import java.time.temporal.ChronoUnit;
+
+@Entity
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Getter
+@EqualsAndHashCode(of = "id", callSuper = false)
+@ToString(exclude = {"goal", "user"})
+public class Stamp extends BaseTimeEntity {
+
+    private static final int STAMP_DAY_MINIMUM = 1;
+    private static final int STAMP_MESSAGE_MAXIMUM = 30;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "goal_id", foreignKey = @ForeignKey(name = "fk_stamp_goal"), nullable = false)
+    private Goal goal;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "user_id", foreignKey = @ForeignKey(name = "fk_stamp_user"), nullable = false)
+    private User user;
+
+    @Column(name = "stamp_day", nullable = false)
+    private int day;
+
+    @Column(columnDefinition = "text", nullable = false, length = STAMP_MESSAGE_MAXIMUM)
+    private String message;
+
+    @Column(name = "is_deleted", nullable = false)
+    private boolean deleted = false;
+
+    @Builder
+    private Stamp(
+            final Goal goal,
+            final User user,
+            final int day,
+            final String message
+    ) {
+        this.goal = goal;
+        this.user = user;
+        this.day = validateDay(goal, day);
+        this.message = validateMessage(message);
+    }
+
+    private int validateDay(final Goal goal, final int day) {
+        final long nowStampDay = ChronoUnit.DAYS.between(goal.getGoalTerm().getStartDate(), LocalDate.now()) + 1;
+
+        if (day > nowStampDay) {
+            throw new InvalidStampException.InvalidStampDayFuture();
+        }
+        if (day > goal.getGoalTerm().getDays()) {
+            throw new InvalidStampException.InvalidStampDay();
+        }
+        if (goal.getGoalTerm().getStartDate().isAfter(LocalDate.now())) {
+            throw new InvalidStampException.InvalidStampDay();
+        }
+
+        return day;
+    }
+
+    private String validateMessage(final String message) {
+        if (message == null || message.isEmpty()) {
+            throw new InvalidStampException.InvalidStampMessage();
+        }
+        if (message.length() > STAMP_MESSAGE_MAXIMUM) {
+            throw new InvalidStampException.InvalidStampMessage();
+        }
+
+        return message;
+    }
+}

src/main/java/com/backend/blooming/stamp/domain/exception/InvalidStampException.java

@@ -0,0 +1,39 @@
+package com.backend.blooming.stamp.domain.exception;
+
+import com.backend.blooming.exception.BloomingException;
+import com.backend.blooming.exception.ExceptionMessage;
+
+public class InvalidStampException extends BloomingException {
+
+    public InvalidStampException(final ExceptionMessage exceptionMessage) {
+        super(exceptionMessage);
+    }
+
+    public static class InvalidStampDay extends InvalidStampException {
+
+        public InvalidStampDay() {
+            super(ExceptionMessage.INVALID_STAMP_DAY);
+        }
+    }
+
+    public static class InvalidStampDayFuture extends InvalidStampException {
+
+        public InvalidStampDayFuture() {
+            super(ExceptionMessage.INVALID_STAMP_DAY_FUTURE);
+        }
+    }
+
+    public static class InvalidStampToCreate extends InvalidStampException {
+
+        public InvalidStampToCreate() {
+            super(ExceptionMessage.INVALID_STAMP_TO_CREATE);
+        }
+    }
+
+    public static class InvalidStampMessage extends InvalidStampException {
+
+        public InvalidStampMessage() {
+            super(ExceptionMessage.INVALID_STAMP_MESSAGE);
+        }
+    }
+}

src/main/java/com/backend/blooming/stamp/infrastructure/repository/StampRepository.java

@@ -0,0 +1,17 @@
+package com.backend.blooming.stamp.infrastructure.repository;
+
+import com.backend.blooming.stamp.domain.Stamp;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+
+public interface StampRepository extends JpaRepository<Stamp, Long> {
+
+    @Query("""
+                SELECT EXISTS(
+                    SELECT 1
+                    FROM Stamp s
+                    WHERE (s.user.id = :userId AND s.day = :day) AND s.deleted = FALSE
+                ) as exist
+            """)
+    boolean existsByUserIdAndDayAndDeletedIsFalse(final Long userId, final int day);
+}