Merge pull request jmprathab#261 from hsergiu/feature/issue-220--move…

…-deleteBooking-to-BookingController

Issue jmprathab#220: Move deleteBooking from AmenityController to BookingController

api/src/main/resources/public/swagger/api.yaml

@@ -134,6 +134,30 @@ paths:
           description: If updated successfully
         '400':
           description: If amenity is not found
+  /amenities/{amenityId}/bookings/{bookingId}:
+    delete:
+      security:
+        - bearerAuth: [ ]
+      tags:
+        - Bookings
+      description: Remove booking
+      operationId: deleteBooking
+      parameters:
+        - in: path
+          name: amenityId
+          required: true
+          schema:
+            type: string
+        - in: path
+          name: bookingId
+          required: true
+          schema:
+            type: string
+      responses:
+        '204':
+          description: If booking deleted
+        '404':
+          description: If params are invalid
   /communities/{communityId}/amenities:
     get:
       security:

service/src/main/java/com/myhome/controllers/AmenityController.java

@@ -31,7 +31,6 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RestController;
@@ -94,15 +93,4 @@ public ResponseEntity<Void> updateAmenity(@PathVariable String amenityId,
       return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
     }
   }
-
-  // TODO: Move to api.yaml
-  @DeleteMapping(path = "/bookings/{bookingId}")
-  public ResponseEntity deleteBooking(@PathVariable String bookingId) {
-    boolean isBookingDeleted = amenitySDJpaService.deleteBooking(bookingId);
-    if (isBookingDeleted) {
-      return ResponseEntity.status(HttpStatus.NO_CONTENT).build();
-    } else {
-      return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
-    }
-  }
 }

service/src/main/java/com/myhome/controllers/BookingController.java

@@ -0,0 +1,29 @@
+package com.myhome.controllers;
+
+import com.myhome.api.BookingsApi;
+import com.myhome.services.BookingService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@Slf4j
+@RequiredArgsConstructor
+public class BookingController implements BookingsApi {
+
+  private final BookingService bookingSDJpaService;
+
+  @Override
+  public ResponseEntity<Void> deleteBooking(@PathVariable String amenityId,
+      @PathVariable String bookingId) {
+    boolean isBookingDeleted = bookingSDJpaService.deleteBooking(amenityId, bookingId);
+    if (isBookingDeleted) {
+      return ResponseEntity.status(HttpStatus.NO_CONTENT).build();
+    } else {
+      return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+    }
+  }
+}

service/src/main/java/com/myhome/domain/Amenity.java

@@ -17,16 +17,21 @@
 package com.myhome.domain;
 
 import java.math.BigDecimal;
+import java.util.HashSet;
+import java.util.Set;
 import javax.persistence.Column;
 import javax.persistence.Entity;
 import javax.persistence.FetchType;
 import javax.persistence.ManyToOne;
 import javax.persistence.NamedAttributeNode;
 import javax.persistence.NamedEntityGraph;
+import javax.persistence.NamedEntityGraphs;
+import javax.persistence.OneToMany;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
+import lombok.ToString;
 import lombok.With;
 
 @Entity
@@ -35,12 +40,21 @@
 @Getter
 @Setter
 @With
-@NamedEntityGraph(
-    name = "Amenity.community",
-    attributeNodes = {
-        @NamedAttributeNode("community"),
-    }
-)
+@NamedEntityGraphs({
+    @NamedEntityGraph(
+        name = "Amenity.community",
+        attributeNodes = {
+            @NamedAttributeNode("community"),
+        }
+    ),
+    @NamedEntityGraph(
+        name = "Amenity.bookingItems",
+        attributeNodes = {
+            @NamedAttributeNode("bookingItems"),
+        }
+    )
+})
+
 public class Amenity extends BaseEntity {
   @Column(nullable = false, unique = true)
   private String amenityId;
@@ -54,4 +68,7 @@ public class Amenity extends BaseEntity {
   private Community community;
   @ManyToOne
   private CommunityHouse communityHouse;
+  @ToString.Exclude
+  @OneToMany(fetch = FetchType.LAZY, mappedBy = "amenity")
+  private Set<AmenityBookingItem> bookingItems = new HashSet<>();
 }

service/src/main/java/com/myhome/domain/AmenityBookingItem.java

@@ -29,18 +29,18 @@
 @Setter
 @With
 @NamedEntityGraphs({
-        @NamedEntityGraph(
-                name="AmenityBookingItem.amenity",
-                attributeNodes = {
-                        @NamedAttributeNode("amenity"),
-                }),
-        @NamedEntityGraph(
-                name="AmenityBookingItem.bookingUser",
-                attributeNodes = {
-                        @NamedAttributeNode("bookingUser"),
-                })
-
+    @NamedEntityGraph(
+        name = "AmenityBookingItem.amenity",
+        attributeNodes = {
+            @NamedAttributeNode("amenity"),
+        }),
+    @NamedEntityGraph(
+        name = "AmenityBookingItem.bookingUser",
+        attributeNodes = {
+            @NamedAttributeNode("bookingUser"),
+        })
 })
+
 public class AmenityBookingItem extends BaseEntity {
 
   @Column(nullable = false, unique = true)

service/src/main/java/com/myhome/repositories/AmenityBookingItemRepository.java

@@ -1,14 +1,9 @@
 package com.myhome.repositories;
 
-import com.myhome.domain.Amenity;
 import com.myhome.domain.AmenityBookingItem;
-import org.springframework.data.jpa.repository.EntityGraph;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
-
 import java.util.Optional;
+import org.springframework.data.jpa.repository.JpaRepository;
 
 public interface AmenityBookingItemRepository extends JpaRepository<AmenityBookingItem, String> {
-    Optional<AmenityBookingItem> findByAmenityBookingItemId(String amenityBookingItemId);
+  Optional<AmenityBookingItem> findByAmenityBookingItemId(String amenityBookingItemId);
 }

service/src/main/java/com/myhome/services/AmenityService.java

@@ -33,6 +33,4 @@ public interface AmenityService {
   Set<Amenity> listAllAmenities(String communityId);
 
   boolean updateAmenity(AmenityDto updatedAmenityDto);
-
-  boolean deleteBooking(String bookingId);
 }

service/src/main/java/com/myhome/services/BookingService.java

@@ -0,0 +1,7 @@
+package com.myhome.services;
+
+public interface BookingService {
+
+  boolean deleteBooking(String amenityId, String bookingId);
+
+}

service/src/main/java/com/myhome/services/springdatajpa/AmenitySDJpaService.java

@@ -20,7 +20,6 @@
 import com.myhome.domain.Amenity;
 import com.myhome.domain.Community;
 import com.myhome.model.AmenityDto;
-import com.myhome.repositories.AmenityBookingItemRepository;
 import com.myhome.repositories.AmenityRepository;
 import com.myhome.repositories.CommunityRepository;
 import com.myhome.services.AmenityService;
@@ -41,7 +40,6 @@ public class AmenitySDJpaService implements AmenityService {
   private final CommunityRepository communityRepository;
   private final CommunityService communityService;
   private final AmenityApiMapper amenityApiMapper;
-  private final AmenityBookingItemRepository bookingRepository;
 
   @Override
   public Optional<List<AmenityDto>> createAmenities(Set<AmenityDto> amenities, String communityId) {
@@ -104,14 +102,4 @@ public boolean updateAmenity(AmenityDto updatedAmenity) {
             .orElse(null))
         .map(amenityRepository::save).isPresent();
   }
-
-  @Override
-  public boolean deleteBooking(String bookingId) {
-    return bookingRepository.findByAmenityBookingItemId(bookingId)
-        .map(bookingItem -> {
-          bookingRepository.delete(bookingItem);
-          return true;
-        })
-        .orElse(false);
-  }
 }

service/src/main/java/com/myhome/services/springdatajpa/BookingSDJpaService.java

@@ -0,0 +1,33 @@
+package com.myhome.services.springdatajpa;
+
+import com.myhome.domain.AmenityBookingItem;
+import com.myhome.repositories.AmenityBookingItemRepository;
+import com.myhome.services.BookingService;
+import java.util.Optional;
+import javax.transaction.Transactional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class BookingSDJpaService implements BookingService {
+
+  private final AmenityBookingItemRepository bookingRepository;
+
+  @Transactional
+  @Override
+  public boolean deleteBooking(String amenityId, String bookingId) {
+    Optional<AmenityBookingItem> booking =
+        bookingRepository.findByAmenityBookingItemId(bookingId);
+    return booking.map(bookingItem -> {
+      boolean amenityFound =
+          bookingItem.getAmenity().getAmenityId().equals(amenityId);
+      if (amenityFound) {
+        bookingRepository.delete(bookingItem);
+        return true;
+      } else {
+        return false;
+      }
+    }).orElse(false);
+  }
+}

service/src/main/java/com/myhome/services/springdatajpa/CommunitySDJpaService.java

@@ -55,7 +55,7 @@ public Community createCommunity(CommunityDto communityDto) {
     communityDto.setCommunityId(generateUniqueId());
     String userId = (String) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
     Community community = addAdminToCommunity(communityMapper.communityDtoToCommunity(communityDto),
-            userId);
+        userId);
     Community savedCommunity = communityRepository.save(community);
     log.trace("saved community with id[{}] to repository", savedCommunity.getId());
     return savedCommunity;

service/src/test/java/com/myhome/controllers/AmenityControllerTest.java

@@ -50,7 +50,6 @@ class AmenityControllerTest {
   private final String TEST_AMENITY_ID = "test-amenity-id";
   private final String TEST_AMENITY_DESCRIPTION = "test-amenity-description";
   private final String TEST_COMMUNITY_ID = "1";
-  private static final String TEST_BOOKING_ID = "test-booking-id";
 
   @Mock
   private AmenityService amenitySDJpaService;
@@ -220,36 +219,6 @@ void shouldNotUpdateCommunityAmenityIfAmenityNotExists() {
     verify(amenitySDJpaService).updateAmenity(amenityDto);
   }
 
-  @Test
-  void deleteBooking() {
-    // given
-    given(amenitySDJpaService.deleteBooking(TEST_BOOKING_ID))
-        .willReturn(true);
-
-    // when
-    ResponseEntity response = amenityController.deleteBooking(TEST_BOOKING_ID);
-
-    // then
-    assertNull(response.getBody());
-    assertEquals(HttpStatus.NO_CONTENT, response.getStatusCode());
-    verify(amenitySDJpaService).deleteBooking(TEST_BOOKING_ID);
-  }
-
-  @Test
-  void deleteBookingNotExists() {
-    // given
-    given(amenitySDJpaService.deleteBooking(TEST_BOOKING_ID))
-        .willReturn(false);
-
-    // when
-    ResponseEntity response = amenityController.deleteBooking(TEST_BOOKING_ID);
-
-    // then
-    assertNull(response.getBody());
-    assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
-    verify(amenitySDJpaService).deleteBooking(TEST_BOOKING_ID);
-  }
-
   private Amenity getTestAmenity() {
     return new Amenity()
         .withAmenityId(TEST_AMENITY_ID)

service/src/test/java/com/myhome/controllers/BookingControllerTest.java

@@ -0,0 +1,64 @@
+package com.myhome.controllers;
+
+import com.myhome.services.BookingService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.verify;
+
+public class BookingControllerTest {
+
+  private final String TEST_AMENITY_ID = "test-amenity-id";
+  private static final String TEST_BOOKING_ID = "test-booking-id";
+
+  @Mock
+  private BookingService bookingSDJpaService;
+
+  @InjectMocks
+  private BookingController bookingController;
+
+  @BeforeEach
+  private void init() {
+    MockitoAnnotations.initMocks(this);
+  }
+
+  @Test
+  void deleteBooking() {
+    // given
+    given(bookingSDJpaService.deleteBooking(TEST_AMENITY_ID, TEST_BOOKING_ID))
+        .willReturn(true);
+
+    // when
+    ResponseEntity<Void> response =
+        bookingController.deleteBooking(TEST_AMENITY_ID, TEST_BOOKING_ID);
+
+    // then
+    assertNull(response.getBody());
+    assertEquals(HttpStatus.NO_CONTENT, response.getStatusCode());
+    verify(bookingSDJpaService).deleteBooking(TEST_AMENITY_ID, TEST_BOOKING_ID);
+  }
+
+  @Test
+  void deleteBookingNotExists() {
+    // given
+    given(bookingSDJpaService.deleteBooking(TEST_AMENITY_ID, TEST_BOOKING_ID))
+        .willReturn(false);
+
+    // when
+    ResponseEntity<Void> response =
+        bookingController.deleteBooking(TEST_AMENITY_ID, TEST_BOOKING_ID);
+
+    // then
+    assertNull(response.getBody());
+    assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+    verify(bookingSDJpaService).deleteBooking(TEST_AMENITY_ID, TEST_BOOKING_ID);
+  }
+}