merge:book api

README.md

@@ -60,7 +60,6 @@ compiler(`⌘,` > `Build, Execution, Deployment` > `Compiler` > `Java Compiler`
 ./gradlew asciidoctor
 ```
 
-
 `/build/asciidoc/html5/api-doc.html` 에서 api 문서를 확인할 수 있습니다.
 
 

build.gradle

@@ -66,6 +66,10 @@ dependencies {
     implementation 'org.hibernate:hibernate-core'
     implementation 'org.hibernate:hibernate-entitymanager'
 
+    implementation group: 'com.fasterxml.jackson.dataformat', name: 'jackson-dataformat-xml', version: '2.18.1'
+    implementation group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.18.1'
+    implementation group: 'com.fasterxml.jackson.core', name: 'jackson-annotations', version: '2.18.1'
+    implementation group: 'com.fasterxml.jackson.core', name: 'jackson-core', version: '2.18.1'
     //compile group: 'io.springfox', name: 'springfox-swagger2', version: '3.0.0'
     //compile group: 'io.springfox', name: 'springfox-swagger-ui', version: '2.9.2'
 

src/main/java/org/poolc/api/activity/domain/Session.java

@@ -98,4 +98,4 @@ public int hashCode() {
         return Objects.hash(getId(), getActivity(), getDescription(), getDate(), getSessionNumber());
     }
 
-}
+}

src/main/java/org/poolc/api/auth/configurations/WebSecurityConfig.java

@@ -39,11 +39,11 @@ public CorsConfigurationSource corsConfigurationSource() {
         CorsConfiguration configuration = new CorsConfiguration();
         configuration.setAllowCredentials(true);
         configuration.setAllowedOrigins(Arrays.asList(
-                "https://alpha.poolc.org", "http://localhost:3000",
-                "https://server.poolc.kr", "http://server.poolc.kr",
-                "http://poolc.kr","https://poolc.kr",
-                "https://poolc.org", "http://poolc.org","https://poolc.org/api", "http://poolc.org/api",
-                "https://dev.poolc.org", "http://dev.poolc.org","https://dev.poolc.org/api", "http://dev.poolc.org/api",
+                "http://localhost:3000",
+                "https://poolc.org", "http://poolc.org"
+                ,"https://poolc.org/api", "http://poolc.org/api",
+                "https://dev.poolc.org", "http://dev.poolc.org"
+                ,"https://api.poolc.org","http://api.poolc.org",
                 "chrome-extension://doeamknhlolnflkmhbhkagganhjjbefe"
         ));
         configuration.setAllowedHeaders(Arrays.asList(
@@ -96,6 +96,7 @@ protected void configure(HttpSecurity http) throws Exception {
                 .antMatchers(HttpMethod.GET, "/book").permitAll()
                 .antMatchers(HttpMethod.GET, "/book/*").permitAll()
                 .antMatchers(HttpMethod.POST, "/book").hasAuthority(MemberRole.ADMIN.name())
+                .antMatchers(HttpMethod.POST, "/book/*").hasAuthority(MemberRole.ADMIN.name())
                 .antMatchers(HttpMethod.PUT, "/book/*").hasAuthority(MemberRole.ADMIN.name())
                 .antMatchers(HttpMethod.DELETE, "/book/*").hasAuthority(MemberRole.ADMIN.name())
                 .antMatchers(HttpMethod.PUT, "/book/borrow/*").hasAuthority(MemberRole.MEMBER.name())

src/main/java/org/poolc/api/badge/service/BadgeService.java

@@ -139,17 +139,16 @@ public Badge getBadgeByBadgeId(Long badgeId){
     }
 
     //뱃지가 존재하고, 해당 뱃지를 받은 적이 없을 경우에만 지급함
+    @Transactional
     public void badgeGiver(Member member, Long badgeId){
         if(duplicateBadgeLogCheck(badgeId, member)&&badgeRepository.findBadgeById(badgeId).isPresent()){
-            if(badgeLogRepository.findBadgeLogByUUID(member.getUUID(),badgeId).isEmpty()) {
-                Badge badge = getBadgeByBadgeId(badgeId);
-                badgeLogRepository.save(BadgeLog.builder()
-                        .member(member)
-                        .date(LocalDate.now())
-                        .badge(badge)
-                        .build());
-                notificationService.createBadgeNotification(member);
-            }
+            Badge badge = getBadgeByBadgeId(badgeId);
+            badgeLogRepository.save(BadgeLog.builder()
+                    .member(member)
+                    .date(LocalDate.now())
+                    .badge(badge)
+                    .build());
+            notificationService.createBadgeNotification(member);
         }
     }
 }

src/main/java/org/poolc/api/book/client/BookClient.java

@@ -0,0 +1,12 @@
+package org.poolc.api.book.client;
+
+import org.poolc.api.book.dto.response.BookApiResponse;
+
+import javax.management.modelmbean.XMLParseException;
+import java.util.List;
+
+public interface BookClient {
+
+    List<BookApiResponse> searchBooks(String query, int page) throws XMLParseException;
+
+}

src/main/java/org/poolc/api/book/client/NaverBookClient.java

@@ -0,0 +1,64 @@
+package org.poolc.api.book.client;
+
+import com.fasterxml.jackson.dataformat.xml.XmlMapper;
+import lombok.RequiredArgsConstructor;
+import org.poolc.api.book.dto.response.BookApiResponse;
+import org.poolc.api.book.dto.response.NaverApiResponse;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.stereotype.Component;
+import org.springframework.web.client.RestTemplate;
+
+import javax.management.modelmbean.XMLParseException;
+import java.util.List;
+
+@Component
+@RequiredArgsConstructor
+public class NaverBookClient implements BookClient{
+
+    @Value("${book.api.url}")
+    private String url;
+
+    @Value("${book.api.secret}")
+    private String clientSecret;
+
+    @Value("${book.api.id}")
+    private String clientId;
+
+    private final RestTemplate restTemplate;
+
+    private static final int PAGE_SIZE = 10;
+
+    @Override
+    public List<BookApiResponse> searchBooks(String query, int page) throws XMLParseException {
+        HttpHeaders headers = new HttpHeaders();
+        headers.set("X-Naver-Client-Id", clientId);
+        headers.set("X-Naver-Client-Secret", clientSecret);
+
+        HttpEntity<String> entity = new HttpEntity<>(headers);
+
+        String url = new StringBuilder(this.url)
+                .append("?query=").append(query)
+                .append("&display=").append(PAGE_SIZE)
+                .append("&start=").append(page * PAGE_SIZE + 1)
+                .toString();
+
+        String xmlResponse = restTemplate.exchange(url, HttpMethod.GET, entity, String.class).getBody();
+
+
+        try {
+            NaverApiResponse naverApiResponse = parseBooks(xmlResponse);
+            return naverApiResponse.getChannel().getItems();
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new XMLParseException("Failed to parse XML response");
+        }
+    }
+
+    private NaverApiResponse parseBooks(String xmlResponse) throws Exception {
+        XmlMapper xmlMapper = new XmlMapper();
+        return xmlMapper.readValue(xmlResponse, NaverApiResponse.class);
+    }
+}

src/main/java/org/poolc/api/book/controller/BookController.java

@@ -1,70 +1,127 @@
 package org.poolc.api.book.controller;
 
 import lombok.RequiredArgsConstructor;
-import org.poolc.api.book.dto.BookRequest;
-import org.poolc.api.book.dto.BookResponse;
+import org.poolc.api.book.client.BookClient;
+import org.poolc.api.book.domain.BookSearchOption;
+import org.poolc.api.book.domain.BookSortOption;
+import org.poolc.api.book.dto.request.CreateBookRequest;
+import org.poolc.api.book.dto.request.UpdateBookRequest;
+import org.poolc.api.book.dto.response.BookApiResponse;
+import org.poolc.api.book.dto.response.BookResponse;
 import org.poolc.api.book.service.BookService;
-import org.poolc.api.book.vo.BookCreateValues;
-import org.poolc.api.book.vo.BookUpdateValues;
 import org.poolc.api.member.domain.Member;
-import org.springframework.http.MediaType;
+import org.springframework.data.domain.Page;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.core.annotation.AuthenticationPrincipal;
 import org.springframework.web.bind.annotation.*;
 
-import java.util.HashMap;
+import javax.validation.Valid;
+import javax.validation.constraints.Min;
 import java.util.List;
 
-import static java.util.stream.Collectors.toList;
-
 @RestController
-@RequiredArgsConstructor
 @RequestMapping("/book")
+@RequiredArgsConstructor
 public class BookController {
 
+    private final BookClient bookClient;
     private final BookService bookService;
 
-    @GetMapping(value = "/{bookID}", produces = MediaType.APPLICATION_JSON_VALUE)
-    public ResponseEntity<BookResponse> findOneBookWithBorrower(@PathVariable("bookID") Long id) {
-        return ResponseEntity.ok().body(BookResponse.of(bookService.findOneBook(id)));
+    @GetMapping("/naver/search")
+    public ResponseEntity<List<BookApiResponse>> searchBooksFromAPI(@RequestParam String query,
+                                                             @RequestParam(value = "page", defaultValue = "0") @Min(0) Integer page) {
+        try {
+            return new ResponseEntity<>(bookClient.searchBooks(query, page), HttpStatus.OK);
+        } catch (Exception e) {
+            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    @GetMapping("/search")
+    public ResponseEntity<Page<BookResponse>> searchBooks(
+            @RequestParam(value = "page", defaultValue = "0") @Min(0) Integer page,
+            @RequestParam(value = "search", required = true)BookSearchOption searchOption,
+            @RequestParam(value = "keyword", required = true) String keyword,
+            @RequestParam(value = "sort", required = false) BookSortOption sortOption) {
+        try {
+            return new ResponseEntity<>(bookService.searchBooks(page,searchOption,keyword,sortOption), HttpStatus.OK);
+        } catch (Exception e) {
+            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
+        }
     }
 
-    @GetMapping(produces = MediaType.APPLICATION_JSON_VALUE)
-    public ResponseEntity<HashMap<String, List<BookResponse>>> findBooks() {
-        HashMap<String, List<BookResponse>> responseBody = new HashMap<>();
-        responseBody.put("data", bookService.findBooks().stream()
-                .map(BookResponse::of)
-                .collect(toList()));
-        return ResponseEntity.ok().body(responseBody);
+    @GetMapping("/all")
+    public ResponseEntity<Page<BookResponse>> getAllBooks(
+            @RequestParam(value = "page", defaultValue = "0") @Min(0) Integer page,
+            @RequestParam(value = "sort", required = false) BookSortOption sortOption) {
+        try {
+            return new ResponseEntity<>(bookService.getAllBooks(page, sortOption), HttpStatus.OK);
+        } catch (Exception e) {
+            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
+        }
     }
 
-    @PostMapping(produces = MediaType.APPLICATION_JSON_VALUE)
-    public ResponseEntity<Void> registerBook(@RequestBody BookRequest requestBody) {
-        bookService.saveBook(new BookCreateValues(requestBody));
-        return ResponseEntity.ok().build();
+    @GetMapping("/{id}")
+    public ResponseEntity<BookResponse> getBook(@PathVariable Long id) {
+        try {
+            return new ResponseEntity<>(bookService.getBook(id), HttpStatus.OK);
+        } catch (Exception e) {
+            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
+        }
     }
 
-    @DeleteMapping(value = "/{bookID}", produces = MediaType.APPLICATION_JSON_VALUE)
-    public ResponseEntity<Void> deleteBook(@PathVariable("bookID") Long id) {
-        bookService.deleteBook(id);
-        return ResponseEntity.ok().build();
+    @PostMapping("/new")
+    public ResponseEntity<Void> addBook(@AuthenticationPrincipal Member member,
+                                     @Valid @RequestBody CreateBookRequest request) {
+        try {
+            bookService.createBook(member, request);
+            return new ResponseEntity<>(HttpStatus.CREATED);
+        } catch (Exception e) {
+            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
+        }
     }
 
-    @PutMapping(value = "/{bookID}", produces = MediaType.APPLICATION_JSON_VALUE)
-    public ResponseEntity<Void> updateBook(@RequestBody BookRequest requestBody, @PathVariable("bookID") Long id) {
-        bookService.updateBook(id, new BookUpdateValues(requestBody));
-        return ResponseEntity.ok().build();
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deleteBook(@AuthenticationPrincipal Member member, @PathVariable Long id) {
+        try {
+            bookService.deleteBook(member, id);
+            return new ResponseEntity<>(HttpStatus.OK);
+        } catch (Exception e) {
+            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
+        }
     }
 
-    @PutMapping(value = "/borrow/{bookID}")
-    public ResponseEntity borrowBook(@AuthenticationPrincipal Member member, @PathVariable("bookID") Long id) {
-        bookService.borrowBook(member, id);
-        return ResponseEntity.ok().build();
+    @PutMapping("/{id}")
+    public ResponseEntity<Void> updateBook(@AuthenticationPrincipal Member member, @PathVariable Long id,
+                                        @Valid @RequestBody UpdateBookRequest request) {
+        try {
+            bookService.updateBook(member, id, request);
+            return new ResponseEntity<>(HttpStatus.OK);
+        } catch (Exception e) {
+            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
+        }
     }
 
-    @PutMapping(value = "/return/{bookID}")
-    public ResponseEntity returnBook(@AuthenticationPrincipal Member member, @PathVariable("bookID") Long id) {
-        bookService.returnBook(member, id);
-        return ResponseEntity.ok().build();
+    @PostMapping("/{id}/borrow")
+    public ResponseEntity<Void> borrowBook(@AuthenticationPrincipal Member member, @PathVariable Long id) {
+        try {
+            bookService.rent(member, id);
+            return new ResponseEntity<>(HttpStatus.OK);
+        } catch (Exception e) {
+            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
+        }
     }
-}
+
+    @PostMapping("/{id}/return")
+    public ResponseEntity<Void> returnBook(@AuthenticationPrincipal Member member, @PathVariable Long id) {
+        try {
+            bookService.returnBook(member, id);
+            return new ResponseEntity<>(HttpStatus.OK);
+        } catch (Exception e) {
+            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+    }
+
+
+}