[#33] 피드를 여행일지로 묶기

src/main/java/com/stoury/batch/BatchHotFeedsConfig.java

@@ -0,0 +1,133 @@
+package com.stoury.batch;
+
+import com.stoury.domain.Feed;
+import com.stoury.dto.feed.SimpleFeedResponse;
+import com.stoury.repository.LikeRepository;
+import com.stoury.repository.RankingRepository;
+import jakarta.persistence.EntityManagerFactory;
+import lombok.RequiredArgsConstructor;
+import org.springframework.batch.core.Job;
+import org.springframework.batch.core.Step;
+import org.springframework.batch.core.job.builder.JobBuilder;
+import org.springframework.batch.core.repository.JobRepository;
+import org.springframework.batch.core.step.builder.StepBuilder;
+import org.springframework.batch.item.ItemProcessor;
+import org.springframework.batch.item.ItemWriter;
+import org.springframework.batch.item.database.JpaPagingItemReader;
+import org.springframework.batch.item.database.builder.JpaPagingItemReaderBuilder;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.util.Pair;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
+import org.springframework.transaction.PlatformTransactionManager;
+
+import java.time.temporal.ChronoUnit;
+
+@Configuration
+@RequiredArgsConstructor
+@ConditionalOnExpression("'${spring.batch.job.names}'.contains('jobHotFeeds')")
+public class BatchHotFeedsConfig {
+    private final EntityManagerFactory entityManagerFactory;
+
+    private final RankingRepository rankingRepository;
+
+    @Bean
+    public Job jobDailyFeed(JobRepository jobRepository, PlatformTransactionManager tm,
+                            ThreadPoolTaskExecutor taskExecutor, LikeRepository likeRepository) {
+        return new JobBuilder("jobDailyFeed", jobRepository)
+                .start(stepDailyFeed(jobRepository, tm, taskExecutor, likeRepository))
+                .build();
+    }
+
+    @Bean
+    public Job jobWeeklyFeed(JobRepository jobRepository, PlatformTransactionManager tm,
+                             ThreadPoolTaskExecutor taskExecutor, LikeRepository likeRepository) {
+        return new JobBuilder("jobWeeklyFeed", jobRepository)
+                .start(stepWeeklyFeed(jobRepository, tm, taskExecutor, likeRepository))
+                .build();
+    }
+
+    @Bean
+    public Job jobMonthlyFeed(JobRepository jobRepository, PlatformTransactionManager tm,
+                              ThreadPoolTaskExecutor taskExecutor, LikeRepository likeRepository) {
+        return new JobBuilder("jobMonthlyFeed", jobRepository)
+                .start(stepMonthlyFeed(jobRepository, tm, taskExecutor, likeRepository))
+                .build();
+    }
+
+    @Bean
+    public Step stepDailyFeed(JobRepository jobRepository, PlatformTransactionManager tm,
+                              ThreadPoolTaskExecutor taskExecutor, LikeRepository likeRepository) {
+        return new StepBuilder("stepDailyFeed", jobRepository)
+                .<Feed, Pair<SimpleFeedResponse, Long>>chunk(100, tm)
+                .reader(feedReader())
+                .processor(feedProcessor(likeRepository, ChronoUnit.DAYS))
+                .writer(feedWriter(ChronoUnit.DAYS))
+                .taskExecutor(taskExecutor)
+                .build();
+    }
+
+    @Bean
+    public Step stepWeeklyFeed(JobRepository jobRepository, PlatformTransactionManager tm,
+                               ThreadPoolTaskExecutor taskExecutor, LikeRepository likeRepository) {
+        return new StepBuilder("stepWeeklyFeed", jobRepository)
+                .<Feed, Pair<SimpleFeedResponse, Long>>chunk(100, tm)
+                .reader(feedReader())
+                .processor(feedProcessor(likeRepository, ChronoUnit.WEEKS))
+                .writer(feedWriter(ChronoUnit.WEEKS))
+                .taskExecutor(taskExecutor)
+                .build();
+    }
+
+    @Bean
+    public Step stepMonthlyFeed(JobRepository jobRepository, PlatformTransactionManager tm,
+                                ThreadPoolTaskExecutor taskExecutor, LikeRepository likeRepository) {
+        return new StepBuilder("stepMonthlyFeed", jobRepository)
+                .<Feed, Pair<SimpleFeedResponse, Long>>chunk(100, tm)
+                .reader(feedReader())
+                .processor(feedProcessor(likeRepository, ChronoUnit.MONTHS))
+                .writer(feedWriter(ChronoUnit.MONTHS))
+                .taskExecutor(taskExecutor)
+                .build();
+    }
+
+
+    public JpaPagingItemReader<Feed> feedReader() {
+        return new JpaPagingItemReaderBuilder<Feed>()
+                .name("feedReader")
+                .pageSize(100)
+                .entityManagerFactory(entityManagerFactory)
+                .queryString("select f from Feed f")
+                .build();
+    }
+
+    public ItemProcessor<Feed, Pair<SimpleFeedResponse, Long>> feedProcessor(LikeRepository likeRepository, ChronoUnit chronoUnit) {
+        return feed -> {
+            Long feedId = feed.getId();
+
+            if (!likeRepository.existsByFeedId(feedId.toString())) {
+                return null;
+            }
+            long currentLikes = likeRepository.getCountByFeedId(feedId.toString());
+            long prevLikes = likeRepository.getCountSnapshotByFeed(feedId.toString(), chronoUnit);
+
+            SimpleFeedResponse simpleFeed = SimpleFeedResponse.from(feed);
+
+            return Pair.of(simpleFeed, currentLikes - prevLikes);
+        };
+    }
+
+    public ItemWriter<Pair<SimpleFeedResponse, Long>> feedWriter(ChronoUnit chronoUnit) {
+        return list -> {
+            for (Pair<SimpleFeedResponse, Long> pair : list) {
+                SimpleFeedResponse rawSimpleFeed = pair.getFirst();
+                Long likeIncrease = pair.getSecond();
+
+                if (likeIncrease > 0) {
+                    rankingRepository.saveHotFeed(rawSimpleFeed, likeIncrease, chronoUnit);
+                }
+            }
+        };
+    }
+}

src/main/java/com/stoury/config/batch/BatchConfig.java → src/main/java/com/stoury/batch/BatchPopularSpotsConfig.java

@@ -1,8 +1,8 @@
-package com.stoury.config.batch;
+package com.stoury.batch;
 
 import com.stoury.repository.FeedRepository;
 import com.stoury.repository.RankingRepository;
-import com.stoury.utils.CacheKeys;
+import com.stoury.utils.cachekeys.PopularSpotsKey;
 import lombok.RequiredArgsConstructor;
 import org.springframework.batch.core.Job;
 import org.springframework.batch.core.Step;
@@ -12,30 +12,31 @@
 import org.springframework.batch.core.repository.JobRepository;
 import org.springframework.batch.core.step.builder.StepBuilder;
 import org.springframework.batch.repeat.RepeatStatus;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
-import org.springframework.scheduling.annotation.EnableScheduling;
 import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 import org.springframework.transaction.PlatformTransactionManager;
 
 import java.util.List;
 
 @Configuration
-@EnableScheduling
 @RequiredArgsConstructor
-public class BatchConfig {
+@ConditionalOnExpression("'${spring.batch.job.names}'.contains('jobPopularSpots')")
+public class BatchPopularSpotsConfig {
     Pageable pageable = PageRequest.of(0, 10);
     private final FeedRepository feedRepository;
     private final RankingRepository rankingRepository;
 
+
     @Bean
     public Step stepUpdatePopularDomesticCities(JobRepository jobRepository, PlatformTransactionManager tm) {
         return new StepBuilder("stepUpdatePopularDomesticCities", jobRepository)
                 .tasklet((contribution, chunkContext) -> {
                     List<String> rankedDomesticCities = feedRepository.findTop10CitiesInKorea(pageable);
-                    rankingRepository.update(CacheKeys.POPULAR_DOMESTIC_SPOTS, rankedDomesticCities);
+                    rankingRepository.update(PopularSpotsKey.POPULAR_DOMESTIC_SPOTS, rankedDomesticCities);
                     return RepeatStatus.FINISHED;
                 }, tm)
                 .build();
@@ -46,7 +47,7 @@ public Step stepUpdatePopularAbroadCities(JobRepository jobRepository, PlatformT
         return new StepBuilder("stepUpdatePopularAbroadCities", jobRepository)
                 .tasklet((contribution, chunkContext) -> {
                     List<String> rankedCountries = feedRepository.findTop10CountriesNotKorea(pageable);
-                    rankingRepository.update(CacheKeys.POPULAR_ABROAD_SPOTS, rankedCountries);
+                    rankingRepository.update(PopularSpotsKey.POPULAR_ABROAD_SPOTS, rankedCountries);
                     return RepeatStatus.FINISHED;
                 }, tm)
                 .build();

src/main/java/com/stoury/config/ContextConfiguration.java

@@ -23,11 +23,9 @@ public PasswordEncoder passwordEncoder() {
     public GeoApiContext geoApiContext() {
         return new GeoApiContext.Builder()
                 .apiKey(apiKey)
-                .connectTimeout(5, TimeUnit.SECONDS)
+                .connectTimeout(2, TimeUnit.SECONDS)
                 .readTimeout(3, TimeUnit.SECONDS)
-                .retryTimeout(2, TimeUnit.SECONDS)
-                .writeTimeout(5, TimeUnit.SECONDS)
-                .maxRetries(5)
+                .maxRetries(3)
                 .build();
     }
 }

src/main/java/com/stoury/config/security/SecurityConfig.java

@@ -34,8 +34,9 @@ public SecurityFilterChain securityFilterChain(HttpSecurity http, HandlerMapping
                         .requestMatchers(new MvcRequestMatcher.Builder(introspector).pattern(HttpMethod.GET, "/feeds/member/**")).permitAll()
                         .requestMatchers(new MvcRequestMatcher.Builder(introspector).pattern(HttpMethod.GET, "/feeds/tag/**")).permitAll()
                         .requestMatchers(new MvcRequestMatcher.Builder(introspector).pattern(HttpMethod.GET, "/feeds/popular/*")).permitAll()
-                        .requestMatchers(new MvcRequestMatcher.Builder(introspector).pattern(HttpMethod.GET, "/feeds/*")).permitAll()
                         .requestMatchers(new MvcRequestMatcher.Builder(introspector).pattern(HttpMethod.GET, "/comments/**")).permitAll()
+                        .requestMatchers(new MvcRequestMatcher.Builder(introspector).pattern(HttpMethod.GET, "/rank/**")).permitAll()
+                        .requestMatchers(new MvcRequestMatcher.Builder(introspector).pattern(HttpMethod.GET, "/diaries/**")).permitAll()
                         .anyRequest().authenticated())
                 .exceptionHandling(exHandler -> exHandler
                         .authenticationEntryPoint((request, response, authException) -> response

src/main/java/com/stoury/controller/CommentController.java

@@ -5,7 +5,6 @@
 import com.stoury.dto.member.AuthenticatedMember;
 import com.stoury.service.CommentService;
 import lombok.RequiredArgsConstructor;
-import org.springframework.http.ResponseEntity;
 import org.springframework.security.core.annotation.AuthenticationPrincipal;
 import org.springframework.web.bind.annotation.*;
 
@@ -46,8 +45,8 @@ public List<ChildCommentResponse> getChildComments(@PathVariable Long commentId,
     }
 
     @DeleteMapping("/comments/{commentId}")
-    public ResponseEntity<Object> deleteComment(@PathVariable Long commentId) {
-        commentService.deleteComment(commentId);
-        return ResponseEntity.ok().build();
+    public void deleteComment(@AuthenticationPrincipal AuthenticatedMember authenticatedMember,
+                              @PathVariable Long commentId) {
+        commentService.deleteCommentIfOwner(commentId, authenticatedMember.getId());
     }
 }

src/main/java/com/stoury/controller/DiaryController.java

@@ -0,0 +1,34 @@
+package com.stoury.controller;
+
+import com.stoury.dto.diary.DiaryCreateRequest;
+import com.stoury.dto.diary.DiaryPageResponse;
+import com.stoury.dto.diary.DiaryResponse;
+import com.stoury.dto.member.AuthenticatedMember;
+import com.stoury.service.DiaryService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequiredArgsConstructor
+public class DiaryController {
+    private final DiaryService diaryService;
+
+    @PostMapping("/diaries")
+    public DiaryResponse createDiary(@AuthenticationPrincipal AuthenticatedMember authenticatedMember,
+                                     @RequestBody(required = true) DiaryCreateRequest diaryCreateRequest) {
+        return diaryService.createDiary(diaryCreateRequest, authenticatedMember.getId());
+    }
+
+    @GetMapping("/diaries/member/{memberId}")
+    public DiaryPageResponse getMemberDiaries(@PathVariable Long memberId,
+                                              @RequestParam(required = false, defaultValue = "0") int pageNo) {
+        return diaryService.getMemberDiaries(memberId, pageNo);
+    }
+
+    @DeleteMapping("/diaries/{diaryId}")
+    public void cancelDiary(@AuthenticationPrincipal AuthenticatedMember authenticatedMember,
+                            @PathVariable Long diaryId) {
+        diaryService.cancelDiaryIfOwner(diaryId, authenticatedMember.getId());
+    }
+}

src/main/java/com/stoury/controller/ExceptionController.java

@@ -2,24 +2,40 @@
 
 import com.stoury.dto.ErrorResponse;
 import com.stoury.exception.AlreadyLikedFeedException;
+import com.stoury.exception.diary.DiaryCreateException;
+import com.stoury.exception.diary.DiarySearchException;
 import com.stoury.exception.feed.FeedCreateException;
 import com.stoury.exception.feed.FeedSearchException;
 import com.stoury.exception.feed.FeedUpdateException;
+import com.stoury.exception.location.GeocodeApiException;
+import com.stoury.exception.member.MemberCreateException;
+import com.stoury.exception.member.MemberDeleteException;
 import com.stoury.exception.member.MemberSearchException;
+import com.stoury.exception.member.MemberUpdateException;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
 
 @RestControllerAdvice
 public class ExceptionController {
-    @ExceptionHandler(value = {FeedCreateException.class, FeedUpdateException.class, AlreadyLikedFeedException.class})
+    @ExceptionHandler(value = {
+            FeedCreateException.class, FeedUpdateException.class,
+            AlreadyLikedFeedException.class,
+            IllegalArgumentException.class,
+            DiaryCreateException.class,
+            MemberCreateException.class, MemberDeleteException.class, MemberUpdateException.class})
     public ResponseEntity<ErrorResponse> handle400(RuntimeException ex) {
         return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(ErrorResponse.of(ex.getMessage()));
     }
 
-    @ExceptionHandler(value = {FeedSearchException.class, MemberSearchException.class})
+    @ExceptionHandler(value = {FeedSearchException.class, MemberSearchException.class, DiarySearchException.class})
     public ResponseEntity<ErrorResponse> handle404(RuntimeException ex) {
         return ResponseEntity.status(HttpStatus.NOT_FOUND).body(ErrorResponse.of(ex.getMessage()));
     }
+
+    @ExceptionHandler(value = {GeocodeApiException.class})
+    public ResponseEntity<ErrorResponse> handle500(RuntimeException ex) {
+        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(ErrorResponse.of(ex.getMessage()));
+    }
 }

src/main/java/com/stoury/controller/FeedController.java

@@ -6,9 +6,7 @@
 import com.stoury.dto.member.AuthenticatedMember;
 import com.stoury.service.FeedService;
 import lombok.RequiredArgsConstructor;
-import org.springframework.http.ResponseEntity;
 import org.springframework.security.core.annotation.AuthenticationPrincipal;
-import org.springframework.security.core.userdetails.User;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
 
@@ -46,24 +44,16 @@ public List<FeedResponse> getFeedsOfMember(@PathVariable Long memberId,
         return feedService.getFeedsOfMemberId(memberId, orderThan);
     }
 
-    @GetMapping("/feeds/popular/abroad-spots")
-    public List<String> getPopularAbroadSpots() {
-        return feedService.getPopularAbroadSpots();
-    }
-
-    @GetMapping("/feeds/popular/domestic-spots")
-    public List<String> getPopularDomesticSpots() {
-        return feedService.getPopularDomesticSpots();
-    }
-
     @PutMapping("/feeds/{feedId}")
-    public FeedResponse updateFeed(@PathVariable Long feedId, @RequestBody FeedUpdateRequest feedUpdateRequest) {
-        return feedService.updateFeed(feedId, feedUpdateRequest);
+    public FeedResponse updateFeed(@AuthenticationPrincipal AuthenticatedMember authenticatedMember,
+                                   @PathVariable Long feedId,
+                                   @RequestBody FeedUpdateRequest feedUpdateRequest) {
+        return feedService.updateFeedIfOwner(feedId, feedUpdateRequest, authenticatedMember.getId());
     }
 
     @DeleteMapping("/feeds/{feedId}")
-    public ResponseEntity<Object> deleteFeed(@PathVariable Long feedId) {
-        feedService.deleteFeed(feedId);
-        return ResponseEntity.ok().build();
+    public void deleteFeed(@AuthenticationPrincipal AuthenticatedMember authenticatedMember,
+                           @PathVariable Long feedId) {
+        feedService.deleteFeedIfOwner(feedId, authenticatedMember.getId());
     }
 }