[fix] 깃 레포 delete 매핑 및 이메일 등록 오류 수정

src/main/java/com/specialwarriors/conal/github/service/GitHubService.java

@@ -29,86 +29,86 @@ public class GitHubService {
     public Mono<Void> updateRepoContribution(String owner, String repo) {
 
         return getContributors(owner, repo)
-                .flatMapMany(contributors -> {
-                    String contributorKey = buildContributorsKey(owner, repo);
-                    List<String> logins = contributors.stream()
-                            .map(GitHubContributor::login)
-                            .collect(Collectors.toList());
-
-                    return reactiveRedisTemplate.delete(contributorKey)
-                            .thenMany(Flux.fromIterable(logins))
-                            .flatMap(login -> reactiveRedisTemplate.opsForList()
-                                    .rightPush(contributorKey, login))
-                            .then(reactiveRedisTemplate.expire(contributorKey, TTL))
-                            .thenMany(Flux.fromIterable(contributors));
-                })
-                .flatMap(contributor -> updateContributorScore(owner, repo, contributor))
-                .then();
+            .flatMapMany(contributors -> {
+                String contributorKey = buildContributorsKey(owner, repo);
+                List<String> logins = contributors.stream()
+                    .map(GitHubContributor::login)
+                    .collect(Collectors.toList());
+
+                return reactiveRedisTemplate.delete(contributorKey)
+                    .thenMany(Flux.fromIterable(logins))
+                    .flatMap(login -> reactiveRedisTemplate.opsForList()
+                        .rightPush(contributorKey, login))
+                    .then(reactiveRedisTemplate.expire(contributorKey, TTL))
+                    .thenMany(Flux.fromIterable(contributors));
+            })
+            .flatMap(contributor -> updateContributorScore(owner, repo, contributor))
+            .then();
     }
 
     private Mono<List<GitHubContributor>> getContributors(String owner, String repo) {
 
         return githubWebClient.get()
-                .uri("/repos/{owner}/{repo}/contributors", owner, repo)
-                .retrieve()
-                .bodyToFlux(GitHubContributor.class)
-                .collectList();
+            .uri("/repos/{owner}/{repo}/contributors", owner, repo)
+            .retrieve()
+            .bodyToFlux(GitHubContributor.class)
+            .collectList();
     }
 
     private Mono<Void> updateContributorScore(String owner, String repo,
-            GitHubContributor contributor) {
+        GitHubContributor contributor) {
 
         String login = contributor.login();
 
         return Mono.zip(
-                getCommitCount(owner, repo, login),
-                getPullRequestCount(owner, repo, login),
-                getMergedPullRequestCount(owner, repo, login),
-                getIssueCount(owner, repo, login)
+            getCommitCount(owner, repo, login),
+            getPullRequestCount(owner, repo, login),
+            getMergedPullRequestCount(owner, repo, login),
+            getIssueCount(owner, repo, login)
         ).flatMap(tuple -> {
             long commit = tuple.getT1();
             long pr = tuple.getT2();
             long mpr = tuple.getT3();
             long issue = tuple.getT4();
-            long score = commit + pr + mpr + issue;
+            double score = commit * 0.1 + pr * 0.2 + mpr + issue * 0.2;
 
             String detailKey = buildDetailKey(owner, repo, login);
 
             return reactiveRedisTemplate.opsForHash().putAll(detailKey, Map.of(
-                            "commit", String.valueOf(commit),
-                            "pr", String.valueOf(pr),
-                            "mpr", String.valueOf(mpr),
-                            "issue", String.valueOf(issue),
-                            "score", String.valueOf(score)
-                    ))
-                    .then(reactiveRedisTemplate.expire(detailKey, TTL));
+                    "commit", String.valueOf(commit),
+                    "pr", String.valueOf(pr),
+                    "mpr", String.valueOf(mpr),
+                    "issue", String.valueOf(issue),
+                    "score", String.valueOf(score)
+                ))
+                .then(reactiveRedisTemplate.expire(detailKey, TTL));
         }).then();
     }
 
     private Mono<Long> getCommitCount(String owner, String repo, String login) {
 
         return getAllCommits(owner, repo, 1)
-                .filter(commit -> {
-                    Map author = (Map) commit.get("author");
+            .filter(commit -> {
+                Map author = (Map) commit.get("author");
 
-                    return author != null && login.equalsIgnoreCase((String) author.get("login"));
-                })
-                .count();
+                return author != null && login.equalsIgnoreCase((String) author.get("login"));
+            })
+            .count();
     }
 
     private Flux<Map> getAllCommits(String owner, String repo, int page) {
 
         return githubWebClient.get()
-                .uri(uriBuilder -> uriBuilder
-                        .path("/repos/{owner}/{repo}/commits")
-                        .queryParam("per_page", PER_PAGE)
-                        .queryParam("page", page)
-                        .build(owner, repo))
-                .retrieve()
-                .bodyToFlux(Map.class)
-                .collectList()
-                .flatMapMany(list -> list.size() < PER_PAGE ? Flux.fromIterable(list)
-                        : Flux.fromIterable(list).concatWith(getAllCommits(owner, repo, page + 1)));
+            .uri(uriBuilder -> uriBuilder
+                .path("/repos/{owner}/{repo}/commits")
+                .queryParam("per_page", PER_PAGE)
+                .queryParam("page", page)
+                .build(owner, repo))
+            .retrieve()
+            .bodyToFlux(Map.class)
+            .collectList()
+            .flatMapMany(list -> list.size() < PER_PAGE ? Flux.fromIterable(list)
+                : Flux.fromIterable(list).concatWith(getAllCommits(owner, repo, page + 1)));
     }
 
     private Mono<Long> getPullRequestCount(String owner, String repo, String login) {
@@ -127,14 +127,14 @@ private Mono<Long> getIssueCount(String owner, String repo, String login) {
     }
 
     private Mono<Long> queryGithubIssueCount(String owner, String repo, String login,
-            String queryType) {
+        String queryType) {
         String query = String.format("repo:%s/%s+%s+author:%s", owner, repo, queryType, login);
 
         return githubWebClient.get()
-                .uri(uriBuilder -> uriBuilder.path("/search/issues").queryParam("q", query).build())
-                .retrieve()
-                .bodyToMono(Map.class)
-                .map(map -> ((Number) map.get("total_count")).longValue());
+            .uri(uriBuilder -> uriBuilder.path("/search/issues").queryParam("q", query).build())
+            .retrieve()
+            .bodyToMono(Map.class)
+            .map(map -> ((Number) map.get("total_count")).longValue());
     }
 
     private String buildDetailKey(String owner, String repo, String login) {
@@ -154,23 +154,23 @@ public Mono<List<String>> getContributorsFromRedis(String owner, String repo) {
         String key = "contributors:" + owner + ":" + repo;
 
         return reactiveRedisTemplate.opsForList()
-                .range(key, 0, -1)
-                .collectList();
+            .range(key, 0, -1)
+            .collectList();
     }
 
     /**
      * 특정 contributor에 대한 상세 점수 정보 가져오기
      */
     public Mono<Map<String, String>> getContributorDetailFromRedis(String owner, String repo,
-            String contributor) {
+        String contributor) {
         String detailKey = "detail:" + owner + ":" + repo + ":" + contributor;
 
         return reactiveRedisTemplate.opsForHash()
-                .entries(detailKey)
-                .collectMap(
-                        e -> e.getKey().toString(),
-                        e -> e.getValue().toString()
-                );
+            .entries(detailKey)
+            .collectMap(
+                e -> e.getKey().toString(),
+                e -> e.getValue().toString()
+            );
     }
 
 }

src/main/java/com/specialwarriors/conal/github_repo/controller/GithubRepoController.java

@@ -10,6 +10,7 @@
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.ModelAttribute;
 import org.springframework.web.bind.annotation.PathVariable;
@@ -39,7 +40,7 @@ public String showCreateForm(@SessionAttribute Long userId, Model model) {
     // 저장 (POST)
     @PostMapping
     public String createGitHubRepo(@SessionAttribute Long userId,
-            @ModelAttribute GithubRepoCreateRequest request) {
+        @ModelAttribute GithubRepoCreateRequest request) {
 
         GithubRepoCreateResponse response = githubRepoService.createGithubRepo(userId, request);
         gitHubService.updateRepoContribution(response.owner(), response.repo()).subscribe();
@@ -50,7 +51,7 @@ public String createGitHubRepo(@SessionAttribute Long userId,
     // 목록 조회 (GET)
     @GetMapping
     public String getGithubRepos(@SessionAttribute Long userId,
-            @RequestParam(defaultValue = "0") int page, Model model) {
+        @RequestParam(defaultValue = "0") int page, Model model) {
 
         GithubRepoPageResponse response = githubRepoService.getGithubRepoInfos(userId, page);
         model.addAttribute("repositories", response);
@@ -62,17 +63,17 @@ public String getGithubRepos(@SessionAttribute Long userId,
     // 단일 조회 (GET)
     @GetMapping("/{repositoryId}")
     public String getRepositoryId(@SessionAttribute Long userId,
-            @PathVariable long repositoryId, Model model) {
+        @PathVariable long repositoryId, Model model) {
 
         GithubRepoGetResponse response = githubRepoService.getGithubRepoInfo(userId, repositoryId);
         model.addAttribute("repoInfo", response);
 
         return "repo/detail";
     }
 
-    @PostMapping("/{repositoryId}")
+    @DeleteMapping("/{repositoryId}")
     public String deleteRepository(@SessionAttribute Long userId,
-            @PathVariable long repositoryId) {
+        @PathVariable long repositoryId) {
 
         githubRepoService.deleteRepo(userId, repositoryId);
 

src/main/java/com/specialwarriors/conal/github_repo/service/GithubRepoService.java

@@ -18,6 +18,7 @@
 import com.specialwarriors.conal.user.domain.User;
 import com.specialwarriors.conal.user.service.UserQuery;
 import java.util.List;
+import java.util.Objects;
 import java.util.Set;
 import java.util.regex.Pattern;
 import lombok.RequiredArgsConstructor;
@@ -75,25 +76,40 @@ private void validateCreateRequest(GithubRepoCreateRequest request) {
         if (request.name().isEmpty()) {
             throw new GeneralException(GithubRepoException.NOT_FOUND_GITHUBREPO_NAME);
         }
+
         if (!GITHUB_URL_PATTERN.matcher(request.url()).matches()) {
             throw new GeneralException(GithubRepoException.INVALID_GITHUBREPO_URL);
         }
-        if (request.emails().isEmpty()) {
+
+        long validEmailCount = request.emails().stream()
+            .filter(Objects::nonNull)
+            .filter(email -> !email.trim().isEmpty())
+            .count();
+
+        if (validEmailCount == 0) {
             throw new GeneralException(GithubRepoException.NOT_FOUND_GITHUBREPO_EMAIL);
         }
-        if (request.emails().size() > 5) {
+        if (validEmailCount > 5) {
             throw new GeneralException(GithubRepoException.EXCEED_GITHUBREPO_EMAIL);
         }
+
         for (String email : request.emails()) {
-            if (!EMAIL_PATTERN.matcher(email).matches()) {
-                throw new GeneralException(GithubRepoException.INVALID_GITHUBREPO_EMAIL);
+
+            if (Objects.nonNull(email)) {
+                String trimmed = email.trim();
+                if (!trimmed.isEmpty() && !EMAIL_PATTERN.matcher(trimmed).matches()) {
+                    throw new GeneralException(GithubRepoException.INVALID_GITHUBREPO_EMAIL);
+                }
             }
+
         }
+
         if (request.endDate() == null) {
             throw new GeneralException(GithubRepoException.INVALID_GITHUBREPO_DURATION);
         }
     }
 
+
     private List<Contributor> createAndSaveContributors(Set<String> emails) {
 
         List<Contributor> contributors = emails.stream()

src/main/resources/templates/main/home.html

@@ -153,6 +153,7 @@
       </a>
       <form th:action="@{|/users/repositories/${repository.id}|}" method="post"
             onsubmit="return confirm('정말 레포지토리를 삭제하시겠습니까?');">
+        <input type="hidden" name="_method" value="delete"/>
         <button class="repo-delete" type="submit">x</button>
       </form>
     </div>

src/test/java/com/specialwarriors/conal/ConalApplicationTests.java

@@ -27,4 +27,4 @@ class ConalApplicationTests {
     @Test
     void contextLoads() {
     }
-}
+}