[Feature] 커뮤니티 기능 구현

src/main/java/kr/tennispark/activity/admin/application/impl/ActivityImageAdminService.java

@@ -3,7 +3,7 @@
 
 import kr.tennispark.activity.admin.infrastructure.repository.ActivityImageRepository;
 import kr.tennispark.activity.common.domain.ActivityImage;
-import kr.tennispark.qr.application.S3UploadService;
+import kr.tennispark.common.application.S3UploadService;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;

src/main/java/kr/tennispark/activity/user/application/service/ActivityCertificationService.java

@@ -2,8 +2,8 @@
 
 import kr.tennispark.activity.common.domain.ActivityCertification;
 import kr.tennispark.activity.user.infrastructure.repository.ActivityCertificationRepository;
+import kr.tennispark.common.application.S3UploadService;
 import kr.tennispark.members.common.domain.entity.Member;
-import kr.tennispark.qr.application.S3UploadService;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;

src/main/java/kr/tennispark/advertisement/admin/application/AdvertisementAdminUseCaseImpl.java

@@ -6,7 +6,7 @@
 import kr.tennispark.advertisement.admin.presentation.dto.response.GetAdvertisementResponseDTO;
 import kr.tennispark.advertisement.common.domain.entity.Advertisement;
 import kr.tennispark.advertisement.common.domain.entity.enums.Position;
-import kr.tennispark.qr.application.S3UploadService;
+import kr.tennispark.common.application.S3UploadService;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;

src/main/java/kr/tennispark/qr/application/S3UploadService.java → src/main/java/kr/tennispark/common/application/S3UploadService.java

@@ -1,25 +1,35 @@
-package kr.tennispark.qr.application;
+package kr.tennispark.common.application;
 
 import com.amazonaws.services.s3.AmazonS3;
+import com.amazonaws.services.s3.model.DeleteObjectsRequest;
+import com.amazonaws.services.s3.model.DeleteObjectsRequest.KeyVersion;
 import com.amazonaws.services.s3.model.ObjectMetadata;
 import com.amazonaws.services.s3.model.PutObjectRequest;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
 import java.util.UUID;
-import kr.tennispark.qr.application.exception.ImageUploadFailedException;
+import kr.tennispark.common.application.exception.S3FailedException;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
 
+@Slf4j
 @Service
 @RequiredArgsConstructor
 public class S3UploadService {
 
     private static final String DEFAULT_CONTENT_TYPE = "image/png";
     private static final String DEFAULT_EXTENSION = ".png";
     private static final String SLASH = "/";
+    private static final int KEY_START_INDEX = 1;
 
     private final AmazonS3 amazonS3;
 
@@ -40,7 +50,7 @@ public String uploadImageFile(MultipartFile image, String keyPrefix) {
                     extension
             );
         } catch (IOException e) {
-            throw new ImageUploadFailedException();
+            throw new S3FailedException("이미지 업로드 실패");
         }
     }
 
@@ -66,4 +76,44 @@ private String extractExtension(String filename) {
         }
         return filename.substring(filename.lastIndexOf("."));
     }
+
+    public void deleteFiles(Collection<String> fileUrls) {
+        if (fileUrls == null || fileUrls.isEmpty()) {
+            return;
+        }
+
+        List<KeyVersion> keys = fileUrls.stream()
+                .filter(Objects::nonNull)
+                .filter(s -> !s.isBlank())
+                .map(url -> {
+                    try {
+                        return new DeleteObjectsRequest.KeyVersion(extractKeyFromUrl(url));
+                    } catch (S3FailedException e) {
+                        log.warn("잘못된 S3 URL로 인해 삭제 대상에서 제외됨: {}", url, e);
+                        return null;
+                    }
+                })
+                .filter(Objects::nonNull)
+                .toList();
+
+        if (keys.isEmpty()) {
+            return;
+        }
+
+        DeleteObjectsRequest request = new DeleteObjectsRequest(bucket).withKeys(keys);
+        amazonS3.deleteObjects(request);
+    }
+
+    private String extractKeyFromUrl(String url) {
+        try {
+            URI uri = new URI(url);
+            String path = uri.getPath();
+            if (path == null || path.length() <= KEY_START_INDEX) {
+                throw new S3FailedException("Invalid S3 URL: " + url);
+            }
+            return path.substring(KEY_START_INDEX);
+        } catch (URISyntaxException e) {
+            throw new S3FailedException("Invalid S3 URL: " + url + "\n" + e);
+        }
+    }
 }

src/main/java/kr/tennispark/qr/application/exception/ImageUploadFailedException.java → src/main/java/kr/tennispark/common/application/exception/S3FailedException.java

@@ -1,17 +1,17 @@
-package kr.tennispark.qr.application.exception;
+package kr.tennispark.common.application.exception;
 
 import kr.tennispark.common.utils.ApiUtils;
 import org.springframework.http.HttpStatus;
 
-public class ImageUploadFailedException extends RuntimeException {
+public class S3FailedException extends RuntimeException {
 
-    private static final String MESSAGE = "이미지 업로드 실패";
+    private static final String MESSAGE = "S3 작업 실패";
 
-    public ImageUploadFailedException (final String message) {
+    public S3FailedException(final String message) {
         super(message);
     }
 
-    public ImageUploadFailedException() {
+    public S3FailedException() {
         this(MESSAGE);
     }
 

src/main/java/kr/tennispark/common/domain/DomainValidator.java

@@ -0,0 +1,14 @@
+package kr.tennispark.common.domain;
+
+import org.springframework.util.StringUtils;
+
+public class DomainValidator {
+
+    public static String requireNonBlank(String value) {
+        if (!StringUtils.hasText(value)) {
+            throw new IllegalArgumentException("빈 문자열을 넣을 수 없습니다.");
+        }
+        return value;
+    }
+}
+

src/main/java/kr/tennispark/common/exception/GlobalExceptionHandler.java

@@ -7,6 +7,7 @@
 import kr.tennispark.auth.common.application.exception.ExpiredTokenException;
 import kr.tennispark.common.exception.base.DuplicateException;
 import kr.tennispark.common.exception.base.InvalidException;
+import kr.tennispark.common.exception.base.NotAuthorizedException;
 import kr.tennispark.common.exception.base.NotFoundException;
 import kr.tennispark.common.exception.base.UnsupportedTypeException;
 import kr.tennispark.common.utils.ApiUtils;
@@ -26,6 +27,7 @@
 import org.springframework.web.bind.MissingServletRequestParameterException;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.method.annotation.HandlerMethodValidationException;
 import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
 import org.springframework.web.servlet.resource.NoResourceFoundException;
 
@@ -54,6 +56,10 @@ public ResponseEntity<?> handleDuplicateException(DuplicateException e) {
         return ResponseEntity.status(e.status()).body(ApiUtils.error(e.status(), e.getMessage()));
     }
 
+    @ExceptionHandler(NotAuthorizedException.class)
+    public ResponseEntity<?> handleNotAuthorizedException(NotAuthorizedException e) {
+        return ResponseEntity.status(e.status()).body(ApiUtils.error(e.status(), e.getMessage()));
+    }
 
     @ExceptionHandler(IllegalArgumentException.class)
     public ResponseEntity<?> handleIllegalArgumentException(IllegalArgumentException e) {
@@ -108,6 +114,15 @@ public ApiUtils.ApiResult<Void> handleMissingServletRequestParameterException(
         return ApiUtils.error(HttpStatus.BAD_REQUEST, message);
     }
 
+    @ExceptionHandler(HandlerMethodValidationException.class)
+    public ApiUtils.ApiResult<Void> handleHandlerMethodValidation(HandlerMethodValidationException e) {
+        String message = e.getAllErrors().stream()
+                .findFirst()
+                .map(err -> err.getDefaultMessage())
+                .orElse("요청 값이 올바르지 않습니다.");
+        return ApiUtils.error(HttpStatus.BAD_REQUEST, message);
+    }
+
     @ExceptionHandler(JwtException.class)
     public ResponseEntity<?> handleJwtException(JwtException ex) {
         return ResponseEntity

src/main/java/kr/tennispark/common/exception/base/NotAuthorizedException.java

@@ -0,0 +1,26 @@
+package kr.tennispark.common.exception.base;
+
+import kr.tennispark.common.utils.ApiUtils;
+import org.springframework.http.HttpStatus;
+
+public class NotAuthorizedException extends RuntimeException {
+
+    private static final String MESSAGE = "해당 리소스에 대한 접근 권한이 없습니다.";
+
+    public NotAuthorizedException(final String message) {
+        super(message);
+    }
+
+    public NotAuthorizedException() {
+        this(MESSAGE);
+    }
+
+    public ApiUtils.ApiResult<?> body() {
+        return ApiUtils.error(HttpStatus.FORBIDDEN, getMessage());
+    }
+
+    public HttpStatus status() {
+        return HttpStatus.FORBIDDEN;
+    }
+}
+

src/main/java/kr/tennispark/post/common/domain/entity/Comment.java

@@ -0,0 +1,64 @@
+package kr.tennispark.post.common.domain.entity;
+
+import static kr.tennispark.common.domain.DomainValidator.requireNonBlank;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import kr.tennispark.common.domain.BaseEntity;
+import kr.tennispark.members.common.domain.entity.Member;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.SQLDelete;
+import org.hibernate.annotations.SQLRestriction;
+
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Entity
+@Table(name = "post_comment")
+@SQLRestriction("status = true")
+@SQLDelete(sql = "UPDATE post_comment SET status = false WHERE id = ?")
+public class Comment extends BaseEntity {
+
+    @ManyToOne(fetch = FetchType.LAZY, optional = false)
+    @JoinColumn(name = "post_id", nullable = false)
+    private Post post;
+
+    @ManyToOne(fetch = FetchType.LAZY, optional = false)
+    @JoinColumn(name = "member_id", nullable = false)
+    private Member member;
+
+    @Column(nullable = false, length = 2000)
+    private String content;
+
+    @Column(name = "photo_url", length = 1000)
+    private String photoUrl;
+
+    private Comment(Post post, Member member, String content, String photoUrl) {
+        this.post = post;
+        this.member = member;
+        this.content = requireNonBlank(content);
+        this.photoUrl = photoUrl;
+        this.post.increaseComment();
+    }
+
+    public static Comment create(Post post, Member member, String content, String photoUrl) {
+        return new Comment(post, member, content, photoUrl);
+    }
+
+    public void update(String newContent, String photoUrl) {
+        this.content = requireNonBlank(newContent);
+        this.photoUrl = photoUrl;
+    }
+
+    public void remove() {
+        if (!isDeleted()) {
+            this.post.decreaseComment();
+            delete();
+        }
+    }
+}

src/main/java/kr/tennispark/post/common/domain/entity/Post.java

@@ -0,0 +1,95 @@
+package kr.tennispark.post.common.domain.entity;
+
+
+import static kr.tennispark.common.domain.DomainValidator.requireNonBlank;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Embedded;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import kr.tennispark.common.domain.BaseEntity;
+import kr.tennispark.members.common.domain.entity.Member;
+import kr.tennispark.post.common.domain.entity.vo.Photos;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.ColumnDefault;
+import org.hibernate.annotations.SQLDelete;
+import org.hibernate.annotations.SQLRestriction;
+
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Entity
+@Table(name = "community_post")
+@SQLDelete(sql = "UPDATE community_post SET status = false WHERE id = ?")
+@SQLRestriction("status = true")
+public class Post extends BaseEntity {
+
+    @ManyToOne(fetch = FetchType.LAZY, optional = false)
+    @JoinColumn(name = "member_id", nullable = false)
+    private Member member;
+
+    @Column(nullable = false, length = 100)
+    private String title;
+
+    @Column(nullable = false, length = 3000)
+    private String content;
+
+    @Embedded
+    private Photos photos;
+
+    @Column(nullable = false)
+    @ColumnDefault("true")
+    private boolean notificationEnabled = true;
+
+    @Column(nullable = false)
+    @ColumnDefault("0")
+    private Integer commentCount = 0;
+
+    @Column(nullable = false)
+    @ColumnDefault("0")
+    private Integer likeCount = 0;
+
+    public static Post create(Member member, String title, String content,
+                              Photos photos) {
+        Post p = new Post();
+        p.member = member;
+        p.title = requireNonBlank(title);
+        p.content = requireNonBlank(content);
+        p.photos = photos != null ? photos : Photos.of(null);
+        return p;
+    }
+
+    public void update(String title, String content,
+                       Photos photos) {
+        this.title = requireNonBlank(title);
+        this.content = requireNonBlank(content);
+        if (photos != null) {
+            this.photos = photos;
+        }
+    }
+
+    public void increaseLike() {
+        this.likeCount++;
+    }
+
+    public void decreaseLike() {
+        if (this.likeCount > 0) {
+            this.likeCount--;
+        }
+    }
+
+    public void increaseComment() {
+        this.commentCount++;
+    }
+
+    public void decreaseComment() {
+        if (this.commentCount > 0) {
+            this.commentCount--;
+        }
+    }
+}
+