🔀 빌드 테스트를 위한 브랜치 머지

dev/sh 브랜치의 값을 머지합니다.

.github/workflows/build.yml

@@ -51,7 +51,9 @@ jobs:
 
       # Gradle로 빌드 실행
       - name: Build with Gradle
-        run: ./gradlew bootJar
+        run: |
+             chmod +x ./gradlew
+             ./gradlew bootJar
 
       # 빌드 결과 Slack 알람 전송
       - name: Send Slack Alarms

src/main/java/com/committers/snowflowerthon/committersserver/auth/config/CorsConfig.java

@@ -0,0 +1,27 @@
+package com.committers.snowflowerthon.committersserver.auth.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.cors.CorsConfigurationSource;
+import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
+
+import java.util.List;
+
+@Configuration
+public class CorsConfig {
+    @Bean
+    public CorsConfigurationSource corsConfigurationSource() {
+        CorsConfiguration corsConfig = new CorsConfiguration();
+
+        corsConfig.setAllowCredentials(true);
+        corsConfig.setAllowedOrigins(List.of("https://kidari.site", "https://kidari-server.shop"));
+        corsConfig.setAllowedMethods(List.of("GET", "POST", "PATCH", "DELETE", "OPTIONS"));
+        corsConfig.setAllowedHeaders(List.of("*"));
+        corsConfig.setAllowedHeaders(List.of("*"));
+        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+        source.registerCorsConfiguration("/**", corsConfig);
+
+        return source;
+    }
+}

src/main/java/com/committers/snowflowerthon/committersserver/auth/config/SecurityConfig.java

@@ -6,6 +6,7 @@
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.http.HttpMethod;
 import org.springframework.security.config.Customizer;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
@@ -47,26 +48,26 @@ public BCryptPasswordEncoder passwordEncoder() {
         return new BCryptPasswordEncoder();
     }
 
-    @Bean
-    public CorsConfigurationSource corsConfigurationSource() {
-
-        CorsConfiguration config = new CorsConfiguration();
-//        config.setAllowedHeaders(Collections.singletonList("*"));
-//        config.setAllowedMethods(Collections.singletonList("*"));
-//        config.addAllowedOriginPattern("http://localhost:3000");
-//        config.addAllowedOriginPattern("https://kidari.site");
-//        config.addAllowedOriginPattern("https://kidari.site:3000");
+//    @Bean
+//    public CorsConfigurationSource corsConfigurationSource() {
+//
+//        CorsConfiguration config = new CorsConfiguration();
+////        config.setAllowedHeaders(Collections.singletonList("*"));
+////        config.setAllowedMethods(Collections.singletonList("*"));
+////        config.addAllowedOriginPattern("http://localhost:3000");
+////        config.addAllowedOriginPattern("https://kidari.site");
+////        config.addAllowedOriginPattern("https://kidari.site:3000");
+////        config.setAllowCredentials(true);
+//
+//        config.addAllowedOriginPattern("*"); // addAllowedOrigin("*")은 allowCredentials(true)랑 같이 사용 불가능
+//        config.addAllowedMethod("*");
+//        config.addAllowedHeader("*");
 //        config.setAllowCredentials(true);
-
-        config.addAllowedOriginPattern("*"); // addAllowedOrigin("*")은 allowCredentials(true)랑 같이 사용 불가능
-        config.addAllowedMethod("*");
-        config.addAllowedHeader("*");
-        config.setAllowCredentials(true);
-
-        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
-        source.registerCorsConfiguration("/**", config);
-        return source;
-    }
+//
+//        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+//        source.registerCorsConfiguration("/**", config);
+//        return source;
+//    }
 
     @Bean
     protected SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
@@ -78,6 +79,7 @@ protected SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
                 .authorizeHttpRequests((authorizeRequests) -> {
                     authorizeRequests
                             .requestMatchers(permitList).permitAll()
+                            .requestMatchers(HttpMethod.OPTIONS, "/**").permitAll()
                             .anyRequest().hasAnyAuthority("ROLE_MEMBER");
                 })
 

src/main/java/com/committers/snowflowerthon/committersserver/auth/github/GitHubService.java

@@ -94,9 +94,13 @@ private int getCommits(String nickname, List<RepoResponseDto> repositories) {
             List<CommitResponseDto> commits = gitHubClient.getCommit(repo.full_name, token);
 
             for(CommitResponseDto com : commits) {
+                String committer = com.author.login;
+                if(committer.isEmpty() || committer.isBlank()) {
+                    log.info("커미터 부재");
+                    continue;
+                }
                 log.info("커밋 sha -> {}", com.sha);
                 log.info("커미터 -> {}", com.author.login);
-                String committer = com.author.login;
                 if (committer.equals(nickname)) {
                     totalCommits++;
                 }

src/main/java/com/committers/snowflowerthon/committersserver/auth/jwt/JwtUtils.java

@@ -114,7 +114,7 @@ public String getNicknameFromToken(String token) {
     }
 
     public Long getMemberIdFromToken(String token) {
-        return (Long) getClaims(token).get("memberId");
+        return Long.valueOf(getClaims(token).get("memberId").toString());
     }
 
     public Role getRoleFromToken(String token) {

src/main/java/com/committers/snowflowerthon/committersserver/common/response/exception/ErrorCode.java

@@ -37,7 +37,12 @@ public enum ErrorCode {
 
     // Univ
     UNIV_NOT_FOUND(404, "존재하지 않는 대학입니다."),
+    UNIV_REGISTER_BAD_REQUEST(404, "대학교 등록/취소 잘못된 요청입니다."),
+    UNIV_CANNOT_BE_REGISTERED(404, "현재 등록한 대학이 있어 새로운 대학을 등록할 수 없습니다."),
 
+    // Snowflake를 사용할 수 없음
+    SNOWFLAKE_CANNOT_BE_USED(404, "현재 보유 중인 눈송이가 없습니다."),
+
     ;
 
     private final int statusCode;

src/main/java/com/committers/snowflowerthon/committersserver/common/validation/ValidationService.java

@@ -1,20 +1,21 @@
 package com.committers.snowflowerthon.committersserver.common.validation;
 
 import com.committers.snowflowerthon.committersserver.common.response.exception.*;
+import com.committers.snowflowerthon.committersserver.domain.item.entity.Item;
+import com.committers.snowflowerthon.committersserver.domain.item.entity.ItemRepository;
 import com.committers.snowflowerthon.committersserver.domain.member.entity.Member;
 import com.committers.snowflowerthon.committersserver.domain.member.entity.MemberRepository;
 import com.committers.snowflowerthon.committersserver.domain.univ.entity.Univ;
 import com.committers.snowflowerthon.committersserver.domain.univ.entity.UnivRepository;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
-import java.util.List;
-
 @RequiredArgsConstructor
 @Service
 public class ValidationService {
 
     private final MemberRepository memberRepository;
+    private final ItemRepository itemRepository;
     private final UnivRepository univRepository;
 
     public Member valMember(String nickname) {
@@ -26,13 +27,18 @@ public Member valMember(Long memberId) {
         return memberRepository.findById(memberId)
                 .orElseThrow(() -> new MemberException(ErrorCode.MEMBER_NOT_FOUND));
     }
-    // 랭킹에서 리스트 반환 위해
+    /*
     public List<Member> valMemberList(String nickname) {
         List<Member> memberList = memberRepository.findAllByNickname(nickname);
         if (memberList == null || memberList.isEmpty()) {
             throw new MemberException(ErrorCode.MEMBER_NOT_FOUND);
         }
         return memberList;
+    }*/
+
+    public Item valItem(Long itemId) {
+        return itemRepository.findById(itemId)
+                .orElseThrow(() -> new ItemException(ErrorCode.ITEM_NOT_FOUND));
     }
 
     public Univ valUniv(Long univId) {
@@ -44,4 +50,5 @@ public Univ valUniv(String univName) { // 예외를 발생시키지 않음에 
         return univRepository.findByUnivName(univName)
                 .orElse(null);
     }
+
 }

src/main/java/com/committers/snowflowerthon/committersserver/domain/attack/controller/AttackController.java

@@ -1,5 +1,7 @@
 package com.committers.snowflowerthon.committersserver.domain.attack.controller;
 
+import com.committers.snowflowerthon.committersserver.common.response.ApiResponse;
+import com.committers.snowflowerthon.committersserver.common.response.exception.ErrorCode;
 import com.committers.snowflowerthon.committersserver.domain.attack.dto.AttackDto;
 import com.committers.snowflowerthon.committersserver.domain.attack.service.AttackService;
 import lombok.RequiredArgsConstructor;
@@ -11,23 +13,23 @@
 
 @RestController
 @RequiredArgsConstructor
-@CrossOrigin(origins = "https://kidari.site")
+@CrossOrigin(origins = "https://kidari.site", allowedHeaders = "*")
 @RequestMapping("/api/v1")
 public class AttackController {
 
     public final AttackService attackService;
 
-    @GetMapping("/home/alarm")
-    public ResponseEntity<List<AttackDto>> getAlarms() {
-        List<AttackDto> alarmList = attackService.findAlarms();
-        return ResponseEntity.ok().body(alarmList); // null일 수 있음
+    @GetMapping("/home/alarm") // 알림 조회 (공격받은 목록 조회)
+    public ResponseEntity<?> getAlarms() {
+        List<AttackDto> attackedList = attackService.findAlarms();
+        return ResponseEntity.ok().body(ApiResponse.success(attackedList)); // null일 수 있음
     }
 
     @PatchMapping("/user/attack")
-    public ResponseEntity<?> attackUser (@RequestParam String nickname) {
+    public ResponseEntity<?> attackUser(@RequestParam String nickname) {
         if (attackService.tryAttack(nickname)) {
-            return ResponseEntity.ok(HttpStatus.CREATED);
+            return ResponseEntity.ok().body(ApiResponse.success()); // 공격 성공
         }
-        return ResponseEntity.badRequest().build();
+        return ResponseEntity.badRequest().body(ApiResponse.failure(ErrorCode.SNOWFLAKE_CANNOT_BE_USED)); // 눈송이를 사용할 수 없는 경우
     }
 }

src/main/java/com/committers/snowflowerthon/committersserver/domain/attack/dto/AttackDto.java

@@ -3,10 +3,12 @@
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
 
 @Builder
 @Getter
 @AllArgsConstructor
+@NoArgsConstructor
 public class AttackDto {
     private String time;
     private String attacker;

src/main/java/com/committers/snowflowerthon/committersserver/domain/attack/service/AttackService.java

@@ -8,6 +8,7 @@
 import com.committers.snowflowerthon.committersserver.domain.member.entity.MemberRepository;
 import com.committers.snowflowerthon.committersserver.domain.member.service.MemberService;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
 import java.time.LocalDateTime;
@@ -16,69 +17,74 @@
 import java.util.Comparator;
 import java.util.List;
 
+@Slf4j
 @Service
 @RequiredArgsConstructor
 public class AttackService {
+    private final ValidationService validationService;
     private final AttackRepository attackRepository;
     private final MemberRepository memberRepository;
-    private final ValidationService validationService;
     private final MemberService memberService;
 
+    // AttackController의 getAlarms 관련
+
     public List<AttackDto> findAlarms() {
         Member member = memberService.getAuthMember();
-        member.alarmChecked();
+        member.alarmChecked();  // 내 알림을 확인된 상태로 변경
         memberRepository.save(member);
+
         List<Attack> attackedList = attackRepository.findAllByMember(member); // 내가 공격받은 목록 가져오기
+        if (attackedList == null || attackedList.isEmpty()) //공격받은 기록이 없는 경우
+            return null;
         attackedList.sort(Comparator.comparing(Attack::getTime).reversed()); // 시간을 최신순으로 정렬
-        List<AttackDto> attackDtoList = new ArrayList<>();
+
+        List<AttackDto> attackDtoList = new ArrayList<>(); // 응답 형식 반환 및 개별 공격 확인 위해 AttackDto 리스트 생성
         for (Attack attack : attackedList) {
-            AttackDto attackDto = formatAttackDto(attack);
-            attackDtoList.add(attackDto);
-            if (!attack.getIsChecked()) {
-                attack.checkAttack(); // 개별 atk의 isChecked 를 true 로 설정
+            attackDtoList.add(formatToAttackDto(attack)); // 형식 변환해 리스트에 넣음
+            if (!attack.getIsChecked()) { // isChecked가 true: 이미 이전에 확인 완료, false: 아직 안 확인(이번에 확인)
+                attack.checkAttack();
             }
-            attackRepository.save(attack); // 저장소 업데이트
+            attackRepository.save(attack); // 저장소에 공격 정보 업데이트해 저장
         }
         return attackDtoList;
     }
 
-    public AttackDto formatAttackDto(Attack attack){ //time 형식 지정
+    public AttackDto formatToAttackDto(Attack attack){ // 응답 형식을 변환(AttackDto; time 형식도 지정한 패턴으로 변환)
         LocalDateTime attackedTime = attack.getTime();
         String timeString = attackedTime.format(DateTimeFormatter.ofPattern("yyyy.MM.dd HH:mm"));
         Long memberId = attack.getAttackerId();
         String attackerName = validationService.valMember(memberId).getNickname();
         return AttackDto.builder()
                 .time(timeString)
-                .attacker(attackerName)
+                .attacker(attackerName)  // 공격자의 이름을 찾아 String형으로 저장
                 .isChecked(attack.getIsChecked())
                 .build();
     }
+
+    // AttackController의 attackUser 관련
 
-    public Boolean tryAttack(String attackedName){
+    public Boolean tryAttack(String attackedName){ // 공격을 시도함
         Member member = memberService.getAuthMember();
-        if (!member.useSnowflake()) { // 눈송이 소모 불가
+        if (!member.useSnowflake()) { // true: 눈송이 소모함, false: 눈송이 소모 불가
             return false;
         }
-        memberRepository.save(member);
-        createAttack(member.getId(), attackedName);
+        memberRepository.save(member); // 변경된 눈송이 갯수 저장
+        createAttack(member.getId(), attackedName); // 공격 생성
         return true;
     }
 
     public void createAttack(Long attackerId, String attackedName){
-        LocalDateTime now = LocalDateTime.now(); // 현재 시각
-        Member attackedMember = validationService.valMember(attackedName);
-        attackedMember.alarmUnchecked(); // 공격받은 사람의 newAlarm 을 true 로 만듬
+        LocalDateTime time = LocalDateTime.now(); // 현재 시각
+        Member attackedMember = validationService.valMember(attackedName); // 공격받은 사람
+        attackedMember.alarmUnchecked(); // 공격받은 사람의 newAlarm 을 true 로
         Attack newAttack = Attack.builder()
-                .time(now)
+                .time(time)
                 .attackerId(attackerId)
                 .isChecked(false)
                 .member(attackedMember)
                 .build();
-        Long snowmanHeight = attackedMember.getSnowmanHeight();
-        if (snowmanHeight > 1) {
-            attackedMember.updateSnowmanHeight(snowmanHeight - 1); // 공격받은 사람 눈사람 키 줄이기
-        }
-        memberRepository.save(attackedMember);
+        attackedMember = memberService.refreshHeight(attackedMember, -1L, attackedMember.getSnowmanHeight() - 1); // 공격받은 사람의 눈사람 키를 줄임
+        log.info("memberService 반환값 -> {}", attackedMember);
         attackRepository.save(newAttack);
     }
 }

src/main/java/com/committers/snowflowerthon/committersserver/domain/follow/controller/FollowController.java

@@ -1,5 +1,7 @@
 package com.committers.snowflowerthon.committersserver.domain.follow.controller;
 
+import com.committers.snowflowerthon.committersserver.common.response.ApiResponse;
+import com.committers.snowflowerthon.committersserver.common.response.exception.ErrorCode;
 import com.committers.snowflowerthon.committersserver.domain.follow.dto.FollowPatchedDto;
 import com.committers.snowflowerthon.committersserver.domain.follow.service.FollowService;
 import lombok.RequiredArgsConstructor;
@@ -8,14 +10,17 @@
 
 @RestController
 @RequiredArgsConstructor
-@CrossOrigin(origins = "https://kidari.site")
+@CrossOrigin(origins = "https://kidari.site", allowedHeaders = "*")
 @RequestMapping("/api/v1")
 public class FollowController {
+
     private final FollowService followService;
 
     @PatchMapping("/buddy/update")
-    public ResponseEntity<FollowPatchedDto> patchFollow(@RequestParam String nickname, @RequestParam boolean isFollowed) {
+    public ResponseEntity<?> patchFollow(@RequestParam String nickname, @RequestParam Boolean isFollowed) {
         FollowPatchedDto followPatchedDto = followService.changeFollowStatus(nickname, isFollowed);
-        return ResponseEntity.ok(followPatchedDto);
+        if (followPatchedDto == null)
+            return ResponseEntity.badRequest().body(ApiResponse.failure(ErrorCode.FOLLOW_BAD_REQUEST));
+        return ResponseEntity.ok().body(ApiResponse.success(followPatchedDto));
     }
 }

src/main/java/com/committers/snowflowerthon/committersserver/domain/follow/dto/FollowPatchedDto.java

@@ -1,8 +1,14 @@
 package com.committers.snowflowerthon.committersserver.domain.follow.dto;
 
 import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
 
+@Builder
+@Getter
 @AllArgsConstructor
+@NoArgsConstructor
 public class FollowPatchedDto {
     private String nickname;
     private boolean isFollowed;