Merge pull request #133 from UnivApp/feature/refactor17

Feature/refactor17

src/main/java/yerong/wedle/category/activity/controller/ActivityApiController.java

@@ -25,7 +25,7 @@ public class ActivityApiController {
             description = "대학교 ID를 이용해 해당 대학교의 활동 목록을 조회합니다."
     )
     @GetMapping
-    public ResponseEntity<List<ActivityResponse>> getActivitiesByㅜ(@RequestParam Long universityId) {
+    public ResponseEntity<List<ActivityResponse>> getActivitiesBy(@RequestParam Long universityId) {
         List<ActivityResponse> activities = activityService.getActivitiesByUniversityId(universityId);
         return ResponseEntity.ok(activities);
     }

src/main/java/yerong/wedle/category/news/domain/News.java

@@ -27,6 +27,6 @@ public class News {
 
     @Column(nullable = false)
     private LocalDate publishedDate;
-    private Integer admissionYear;
+    private String admissionYear;
     private String source;
 }

src/main/java/yerong/wedle/category/news/dto/NewsResponse.java

@@ -15,6 +15,6 @@ public class NewsResponse {
     private String title;
     private String link;
     private LocalDate publishedDate;
-    private Integer admissionYear;
+    private String admissionYear;
     private String source;
 }

src/main/java/yerong/wedle/common/exception/GlobalExceptionHandler.java

@@ -4,13 +4,14 @@
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
-import yerong.wedle.banner.exception.BannerNotFoundException;
 import yerong.wedle.calendar.exception.CalendarEventNotFoundException;
 import yerong.wedle.category.announcement.exception.AdmissionAnnouncementCategoryNotFoundException;
 import yerong.wedle.category.announcement.exception.AdmissionAnnouncementNotFoundException;
 import yerong.wedle.category.news.exception.NewsNotFoundException;
 import yerong.wedle.category.restaurant.exception.RestaurantNotFoundException;
+import yerong.wedle.competitionRate.exception.CompetitionRateNotFoundException;
 import yerong.wedle.department.exception.DepartmentNotFoundException;
+import yerong.wedle.employmentRate.exception.EmploymentRateNotFoundException;
 import yerong.wedle.member.exception.MemberNotFoundException;
 import yerong.wedle.member.exception.MemberDuplicateException;
 import yerong.wedle.oauth.exception.InvalidAuthorizationHeaderException;
@@ -106,6 +107,25 @@ public ResponseEntity<ErrorResponse> handleAdmissionAnnouncementCategoryNotFound
         );
         return ResponseEntity.status(HttpStatus.NOT_FOUND).body(errorResponse);
     }
+
+    @ExceptionHandler(CompetitionRateNotFoundException.class)
+    public ResponseEntity<ErrorResponse> handleCompetitionRateNotFoundException(CompetitionRateNotFoundException ex) {
+        ErrorResponse errorResponse = new ErrorResponse(
+                ResponseCode.COMPETITION_RATE_NOT_FOUND.getCode(),
+                ResponseCode.COMPETITION_RATE_NOT_FOUND.getMessage(),
+                LocalDateTime.now().format(FORMATTER)
+        );
+        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(errorResponse);
+    }
+    @ExceptionHandler(EmploymentRateNotFoundException.class)
+    public ResponseEntity<ErrorResponse> handleEmploymentRateNotFoundException(EmploymentRateNotFoundException ex) {
+        ErrorResponse errorResponse = new ErrorResponse(
+                ResponseCode.EMPLOYMENT_RATE_NOT_FOUND.getCode(),
+                ResponseCode.EMPLOYMENT_RATE_NOT_FOUND.getMessage(),
+                LocalDateTime.now().format(FORMATTER)
+        );
+        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(errorResponse);
+    }
     @ExceptionHandler(NewsNotFoundException.class)
     public ResponseEntity<ErrorResponse> handleNewsNotFoundException(NewsNotFoundException ex) {
         ErrorResponse errorResponse = new ErrorResponse(
@@ -124,15 +144,6 @@ public ResponseEntity<ErrorResponse> handleInvalidAuthorizationHeaderException(I
         );
         return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse);
     }
-    @ExceptionHandler(BannerNotFoundException.class)
-    public ResponseEntity<ErrorResponse> handleBannerNotFoundException(BannerNotFoundException ex) {
-        ErrorResponse errorResponse = new ErrorResponse(
-                ResponseCode.BANNER_NOT_FOUND.getCode(),
-                ResponseCode.BANNER_NOT_FOUND.getMessage(),
-                LocalDateTime.now().format(FORMATTER)
-        );
-        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(errorResponse);
-    }
     @ExceptionHandler(CalendarEventNotFoundException.class)
     public ResponseEntity<ErrorResponse> handleCalendarEventNotFoundException(CalendarEventNotFoundException ex) {
         ErrorResponse errorResponse = new ErrorResponse(

src/main/java/yerong/wedle/common/exception/ResponseCode.java

@@ -44,6 +44,12 @@ public enum ResponseCode {
     //News
     NEWS_NOT_FOUND("404", "기사 정보를 찾을 수 없습니다."),
 
+    //Competition Rate
+    COMPETITION_RATE_NOT_FOUND("404", "경쟁률 정보를 찾을 수 없습니다."),
+
+    //Employment Rate
+    EMPLOYMENT_RATE_NOT_FOUND("404", "취업률 정보를 찾을 수 없습니다."),
+
     //Admission Announcement
     ADMISSION_ANNOUNCEMENT_NOT_FOUND("404", "대학 연계 행사 정보를 찾을 수 없습니다."),
     ADMISSION_ANNOUNCEMENT_CATEGORY_NOT_FOUND("404", "대학 연계 행사 카테고리 정보를 찾을 수 없습니다.");

src/main/java/yerong/wedle/competitionRate/controller/CompetitionRateController.java

@@ -0,0 +1,42 @@
+package yerong.wedle.competitionRate.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import yerong.wedle.category.activity.dto.ActivityResponse;
+import yerong.wedle.competitionRate.dto.CompetitionRateResponse;
+import yerong.wedle.competitionRate.service.CompetitionRateService;
+
+import java.util.List;
+
+@Tag(name = "CompetitionRate API", description = "대학교 경쟁률 API")
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/api/competition-rate")
+public class CompetitionRateController {
+    private final CompetitionRateService competitionRateService;
+    @Operation(
+            summary = "대학교 경쟁률 삼년치 조회",
+            description = "대학교 ID를 이용해 해당 대학교의 경쟁률 삼년치를 조회합니다."
+    )
+    @GetMapping("/three-years")
+    public ResponseEntity<List<CompetitionRateResponse>> getAllCompetitionRates(@RequestParam Long universityId) {
+        List<CompetitionRateResponse> lastThreeYearsCompetitionRates = competitionRateService.getLastThreeYearsCompetitionRates(universityId);
+        return ResponseEntity.ok(lastThreeYearsCompetitionRates);
+    }
+
+    @Operation(
+            summary = "대학교 경쟁률 최근년도 조회",
+            description = "대학교 ID를 이용해 해당 대학교의 경쟁률 최근년도를 조회합니다."
+    )
+    @GetMapping
+    public ResponseEntity<CompetitionRateResponse> getCompetitionRate(@RequestParam Long universityId) {
+        CompetitionRateResponse latestCompetitionRate = competitionRateService.getLatestCompetitionRate(universityId);
+        return ResponseEntity.ok(latestCompetitionRate);
+    }
+}

src/main/java/yerong/wedle/competitionRate/domain/CompetitionRate.java

@@ -0,0 +1,28 @@
+package yerong.wedle.competitionRate.domain;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import yerong.wedle.university.domain.University;
+
+import java.time.LocalDate;
+
+import static jakarta.persistence.GenerationType.*;
+import static lombok.AccessLevel.PROTECTED;
+
+@NoArgsConstructor(access = PROTECTED)
+@Getter
+@Entity
+public class CompetitionRate {
+    @Id
+    @GeneratedValue(strategy = IDENTITY)
+    private Long id;
+
+    @ManyToOne
+    @JoinColumn(name = "university_id", nullable = false)
+    private University university;
+
+    private Double earlyAdmissionRate;
+    private Double regularAdmissionRate;
+    private String competitionYear;
+}

src/main/java/yerong/wedle/competitionRate/dto/CompetitionRateResponse.java

@@ -0,0 +1,14 @@
+package yerong.wedle.competitionRate.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@AllArgsConstructor
+@NoArgsConstructor
+public class CompetitionRateResponse {
+    private Double earlyAdmissionRate;
+    private Double regularAdmissionRate;
+    private String year;
+}

src/main/java/yerong/wedle/competitionRate/exception/CompetitionRateNotFoundException.java

@@ -0,0 +1,10 @@
+package yerong.wedle.competitionRate.exception;
+
+import yerong.wedle.common.exception.CustomException;
+import yerong.wedle.common.exception.ResponseCode;
+
+public class CompetitionRateNotFoundException extends CustomException {
+    public CompetitionRateNotFoundException() {
+        super(ResponseCode.COMPETITION_RATE_NOT_FOUND);
+    }
+}

src/main/java/yerong/wedle/competitionRate/repository/CompetitionRateRepository.java

@@ -0,0 +1,14 @@
+package yerong.wedle.competitionRate.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import yerong.wedle.competitionRate.domain.CompetitionRate;
+import yerong.wedle.university.domain.University;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface CompetitionRateRepository extends JpaRepository<CompetitionRate, Long> {
+    List<CompetitionRate> findByUniversity(University university);
+
+    Optional<CompetitionRate> findTopByUniversityOrderByCompetitionYearDesc(University university);
+}

src/main/java/yerong/wedle/competitionRate/service/CompetitionRateService.java

@@ -0,0 +1,46 @@
+package yerong.wedle.competitionRate.service;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import yerong.wedle.competitionRate.domain.CompetitionRate;
+import yerong.wedle.competitionRate.dto.CompetitionRateResponse;
+import yerong.wedle.competitionRate.exception.CompetitionRateNotFoundException;
+import yerong.wedle.competitionRate.repository.CompetitionRateRepository;
+import yerong.wedle.university.domain.University;
+import yerong.wedle.university.exception.UniversityNotFoundException;
+import yerong.wedle.university.repository.UniversityRepository;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+public class CompetitionRateService {
+
+    private final CompetitionRateRepository competitionRateRepository;
+    private final UniversityRepository universityRepository;
+    @Transactional(readOnly = true)
+    public List<CompetitionRateResponse> getLastThreeYearsCompetitionRates(Long universityId) {
+        University university = universityRepository.findById(universityId).orElseThrow(UniversityNotFoundException::new);
+        List<CompetitionRate> rates = competitionRateRepository.findByUniversity(university);
+
+        return rates.stream()
+                .map(this::convertToDto)
+                .collect(Collectors.toList());
+    }
+    @Transactional(readOnly = true)
+    public CompetitionRateResponse getLatestCompetitionRate(Long universityId) {
+        University university = universityRepository.findById(universityId).orElseThrow(UniversityNotFoundException::new);
+        CompetitionRate latestRate = competitionRateRepository.findTopByUniversityOrderByCompetitionYearDesc(university).orElseThrow(CompetitionRateNotFoundException::new);
+
+        return convertToDto(latestRate);
+    }
+    private CompetitionRateResponse convertToDto(CompetitionRate competitionRate) {
+        return new CompetitionRateResponse(
+                competitionRate.getEarlyAdmissionRate(),
+                competitionRate.getRegularAdmissionRate(),
+                competitionRate.getCompetitionYear()
+        );
+    }
+}