Issue jmprathab#257 fix

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

@@ -24,9 +24,12 @@
 import com.myhome.model.AmenityDto;
 import com.myhome.model.GetAmenityDetailsResponse;
 import com.myhome.model.UpdateAmenityRequest;
+import com.myhome.services.AmenityBookingService;
 import com.myhome.services.AmenityService;
 import java.util.Set;
 import javax.validation.Valid;
+
+import com.myhome.services.CommunityService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.HttpStatus;
@@ -43,6 +46,8 @@ public class AmenityController implements AmenitiesApi {
 
   private final AmenityService amenitySDJpaService;
   private final AmenityApiMapper amenityApiMapper;
+  private final AmenityBookingService amenityBookingService;
+  private final CommunityService communityService;
 
   @Override
   public ResponseEntity<GetAmenityDetailsResponse> getAmenityDetails(
@@ -56,7 +61,7 @@ public ResponseEntity<GetAmenityDetailsResponse> getAmenityDetails(
   @Override
   public ResponseEntity<Set<GetAmenityDetailsResponse>> listAllAmenities(
       @PathVariable String communityId) {
-    Set<Amenity> amenities = amenitySDJpaService.listAllAmenities(communityId);
+    Set<Amenity> amenities = communityService.listAllAmenities(communityId);
     Set<GetAmenityDetailsResponse> response =
         amenityApiMapper.amenitiesSetToAmenityDetailsResponseSet(amenities);
     return ResponseEntity.ok(response);
@@ -98,7 +103,7 @@ public ResponseEntity<Void> updateAmenity(@PathVariable String amenityId,
   // TODO: Move to api.yaml
   @DeleteMapping(path = "/bookings/{bookingId}")
   public ResponseEntity deleteBooking(@PathVariable String bookingId) {
-    boolean isBookingDeleted = amenitySDJpaService.deleteBooking(bookingId);
+    boolean isBookingDeleted = amenityBookingService.deleteBooking(bookingId);
     if (isBookingDeleted) {
       return ResponseEntity.status(HttpStatus.NO_CONTENT).build();
     } else {

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

@@ -18,30 +18,45 @@
 
 import com.myhome.api.CommunitiesApi;
 import com.myhome.controllers.dto.CommunityDto;
+import com.myhome.controllers.mapper.AmenityApiMapper;
 import com.myhome.controllers.mapper.CommunityApiMapper;
+import com.myhome.controllers.mapper.SchedulePaymentApiMapper;
+import com.myhome.domain.Amenity;
 import com.myhome.domain.Community;
 import com.myhome.domain.CommunityHouse;
+import com.myhome.domain.Payment;
 import com.myhome.domain.User;
+import com.myhome.model.AddAmenityRequest;
+import com.myhome.model.AddAmenityResponse;
 import com.myhome.model.AddCommunityAdminRequest;
 import com.myhome.model.AddCommunityAdminResponse;
 import com.myhome.model.AddCommunityHouseRequest;
 import com.myhome.model.AddCommunityHouseResponse;
+import com.myhome.model.AdminPayment;
 import com.myhome.model.CommunityHouseName;
 import com.myhome.model.CreateCommunityRequest;
 import com.myhome.model.CreateCommunityResponse;
+import com.myhome.model.GetAmenityDetailsResponse;
 import com.myhome.model.GetCommunityDetailsResponse;
 import com.myhome.model.GetCommunityDetailsResponseCommunity;
 import com.myhome.model.GetHouseDetailsResponse;
+import com.myhome.model.ListAdminPaymentsResponse;
 import com.myhome.model.ListCommunityAdminsResponse;
+import com.myhome.services.AmenityService;
 import com.myhome.services.CommunityService;
 import java.util.Arrays;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
 import javax.validation.Valid;
+
+import com.myhome.services.PaymentService;
+import com.myhome.utils.PageInfo;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.web.PageableDefault;
 import org.springframework.http.HttpStatus;
@@ -57,8 +72,14 @@
 @RestController
 @Slf4j
 public class CommunityController implements CommunitiesApi {
+
   private final CommunityService communityService;
+  private final AmenityService amenitySDJpaService;
+  private final PaymentService paymentService;
+
   private final CommunityApiMapper communityApiMapper;
+  private final AmenityApiMapper amenityApiMapper;
+  private final SchedulePaymentApiMapper schedulePaymentApiMapper;
 
   @Override
   public ResponseEntity<CreateCommunityResponse> createCommunity(@Valid @RequestBody

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

@@ -7,8 +7,11 @@
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
 
+import java.util.HashSet;
 import java.util.Optional;
 
 public interface AmenityBookingItemRepository extends JpaRepository<AmenityBookingItem, String> {
     Optional<AmenityBookingItem> findByAmenityBookingItemId(String amenityBookingItemId);
+
+    HashSet<AmenityBookingItem> findAllByAmenity_AmenityId(String amenityId);
 }

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

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

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

@@ -17,6 +17,7 @@
 package com.myhome.services;
 
 import com.myhome.controllers.dto.CommunityDto;
+import com.myhome.domain.Amenity;
 import com.myhome.domain.Community;
 import com.myhome.domain.CommunityHouse;
 import com.myhome.domain.User;
@@ -34,6 +35,8 @@ public interface CommunityService {
 
   Optional<Community> getCommunityDetailsById(String communityId);
 
+  Set<Amenity> listAllAmenities(String communityId);
+
   Optional<List<CommunityHouse>> findCommunityHousesById(String communityId, Pageable pageable);
 
   Optional<List<User>> findCommunityAdminsById(String communityId, Pageable pageable);

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

@@ -37,4 +37,6 @@ public interface HouseService {
   Optional<List<HouseMember>> getHouseMembersById(String houseId, Pageable pageable);
 
   Optional<List<HouseMember>> listHouseMembersForHousesOfUserId(String userId, Pageable pageable);
+
+  boolean removeAmenityFromHouse(CommunityHouse house, String amenityId);
 }

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

@@ -20,16 +20,17 @@
 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.AmenityBookingService;
 import com.myhome.services.AmenityService;
 import com.myhome.services.CommunityService;
-import java.util.HashSet;
+
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
+
+import com.myhome.services.HouseService;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
@@ -38,10 +39,10 @@
 public class AmenitySDJpaService implements AmenityService {
 
   private final AmenityRepository amenityRepository;
-  private final CommunityRepository communityRepository;
   private final CommunityService communityService;
   private final AmenityApiMapper amenityApiMapper;
-  private final AmenityBookingItemRepository bookingRepository;
+  private final AmenityBookingService amenityBookingService;
+  private final HouseService houseService;
 
   @Override
   public Optional<List<AmenityDto>> createAmenities(Set<AmenityDto> amenities, String communityId) {
@@ -83,19 +84,11 @@ public boolean deleteAmenity(String amenityId) {
         .orElse(false);
   }
 
-  @Override
-  public Set<Amenity> listAllAmenities(String communityId) {
-    return communityRepository.findByCommunityIdWithAmenities(communityId)
-        .map(Community::getAmenities)
-        .orElse(new HashSet<>());
-  }
-
   @Override
   public boolean updateAmenity(AmenityDto updatedAmenity) {
     String amenityId = updatedAmenity.getAmenityId();
     return amenityRepository.findByAmenityId(amenityId)
-        .map(amenity -> communityRepository.findByCommunityId(updatedAmenity.getCommunityId())
-            .map(community -> {
+        .map(amenity ->  {
               Amenity updated = new Amenity();
               updated.setName(updatedAmenity.getName());
               updated.setPrice(updatedAmenity.getPrice());
@@ -104,17 +97,6 @@ public boolean updateAmenity(AmenityDto updatedAmenity) {
               updated.setDescription(updatedAmenity.getDescription());
               return updated;
             })
-            .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/CommunitySDJpaService.java

@@ -18,6 +18,7 @@
 
 import com.myhome.controllers.dto.CommunityDto;
 import com.myhome.controllers.dto.mapper.CommunityMapper;
+import com.myhome.domain.Amenity;
 import com.myhome.domain.Community;
 import com.myhome.domain.CommunityHouse;
 import com.myhome.domain.HouseMember;
@@ -84,6 +85,13 @@ public Set<Community> listAll(Pageable pageable) {
     return communities;
   }
 
+  @Override
+  public Set<Amenity> listAllAmenities(String communityId) {
+    return communityRepository.findByCommunityIdWithAmenities(communityId)
+        .map(Community::getAmenities)
+        .orElse(new HashSet<>());
+  }
+
   @Override
   public Optional<List<CommunityHouse>> findCommunityHousesById(String communityId,
       Pageable pageable) {

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

@@ -115,4 +115,13 @@ public Optional<List<HouseMember>> listHouseMembersForHousesOfUserId(String user
         houseMemberRepository.findAllByCommunityHouse_Community_Admins_UserId(userId, pageable)
     );
   }
+
+  @Override
+  public boolean removeAmenityFromHouse(CommunityHouse house, String amenityId) {
+    boolean removed = house.getAmenities().removeIf(amenity -> amenity.getAmenityId().equals(amenityId));
+    if (removed) {
+      communityHouseRepository.save(house);
+    }
+    return removed;
+  }
 }

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

@@ -23,6 +23,7 @@
 import com.myhome.model.AmenityDto;
 import com.myhome.model.GetAmenityDetailsResponse;
 import com.myhome.model.UpdateAmenityRequest;
+import com.myhome.services.AmenityBookingService;
 import com.myhome.services.AmenityService;
 import java.math.BigDecimal;
 import java.util.HashSet;
@@ -56,6 +57,8 @@ class AmenityControllerTest {
   private AmenityService amenitySDJpaService;
   @Mock
   private AmenityApiMapper amenityApiMapper;
+  @Mock
+  private AmenityBookingService amenityBookingService;
 
   @InjectMocks
   private AmenityController amenityController;
@@ -223,7 +226,7 @@ void shouldNotUpdateCommunityAmenityIfAmenityNotExists() {
   @Test
   void deleteBooking() {
     // given
-    given(amenitySDJpaService.deleteBooking(TEST_BOOKING_ID))
+    given(amenityBookingService.deleteBooking(TEST_BOOKING_ID))
         .willReturn(true);
 
     // when
@@ -232,13 +235,13 @@ void deleteBooking() {
     // then
     assertNull(response.getBody());
     assertEquals(HttpStatus.NO_CONTENT, response.getStatusCode());
-    verify(amenitySDJpaService).deleteBooking(TEST_BOOKING_ID);
+    verify(amenityBookingService).deleteBooking(TEST_BOOKING_ID);
   }
 
   @Test
   void deleteBookingNotExists() {
     // given
-    given(amenitySDJpaService.deleteBooking(TEST_BOOKING_ID))
+    given(amenityBookingService.deleteBooking(TEST_BOOKING_ID))
         .willReturn(false);
 
     // when
@@ -247,7 +250,7 @@ void deleteBookingNotExists() {
     // then
     assertNull(response.getBody());
     assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
-    verify(amenitySDJpaService).deleteBooking(TEST_BOOKING_ID);
+    verify(amenityBookingService).deleteBooking(TEST_BOOKING_ID);
   }
 
   private Amenity getTestAmenity() {

service/src/test/java/com/myhome/services/unit/AmenityBookingSDJpaServiceTest.java

@@ -0,0 +1,73 @@
+package com.myhome.services.unit;
+
+import com.myhome.domain.AmenityBookingItem;
+import com.myhome.repositories.AmenityBookingItemRepository;
+import com.myhome.services.AmenityBookingService;
+import com.myhome.services.springdatajpa.AmenityBookingSDJpaService;
+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 java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+public class AmenityBookingSDJpaServiceTest {
+
+  private static final String TEST_BOOKING_ID = "test-booking-id";
+  @Mock
+  private AmenityBookingItemRepository bookingItemRepository;
+
+  @InjectMocks
+  private AmenityBookingSDJpaService amenityBookingService;
+
+  @BeforeEach
+  private void init() {
+    MockitoAnnotations.initMocks(this);
+  }
+
+  @Test
+  void deleteBookingItem() {
+    // given
+    AmenityBookingItem testBookingItem = getTestBookingItem();
+
+    given(bookingItemRepository.findByAmenityBookingItemId(TEST_BOOKING_ID))
+        .willReturn(Optional.of(testBookingItem));
+
+    // when
+    boolean bookingDeleted = amenityBookingService.deleteBooking(TEST_BOOKING_ID);
+
+    // then
+    assertTrue(bookingDeleted);
+    verify(bookingItemRepository).findByAmenityBookingItemId(TEST_BOOKING_ID);
+    verify(bookingItemRepository).delete(testBookingItem);
+  }
+
+  @Test
+  void deleteBookingNotExists() {
+    // given
+    given(bookingItemRepository.findByAmenityBookingItemId(TEST_BOOKING_ID))
+        .willReturn(Optional.empty());
+
+    // when
+    boolean amenityDeleted = amenityBookingService.deleteBooking(TEST_BOOKING_ID);
+
+    // then
+    assertFalse(amenityDeleted);
+    verify(bookingItemRepository).findByAmenityBookingItemId(TEST_BOOKING_ID);
+    verify(bookingItemRepository, never()).delete(any());
+  }
+
+  private AmenityBookingItem getTestBookingItem() {
+    return new AmenityBookingItem()
+        .withAmenityBookingItemId(TEST_BOOKING_ID);
+  }
+
+}