#35 move method from controller

oso-backend.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

src/main/kotlin/org/oso/core/controllers/EmergencyController.kt

@@ -1,18 +1,16 @@
 package org.oso.core.controllers
 
 import org.oso.config.Paths
-import org.oso.core.dtos.EmergencyDto
+import org.oso.core.dtos.*
 import org.oso.core.entities.Emergency
 import org.oso.core.exceptions.HelpRequesterNotFoundException
 import org.oso.core.services.EmergencyService
 import org.oso.core.services.HelpRequesterService
 import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.http.HttpStatus
+import org.springframework.http.ResponseEntity
 import org.springframework.stereotype.Controller
-import org.springframework.web.bind.annotation.PostMapping
-import org.springframework.web.bind.annotation.RequestBody
-import org.springframework.web.bind.annotation.RequestMapping
-import org.springframework.web.bind.annotation.ResponseStatus
+import org.springframework.web.bind.annotation.*
 
 
 @Controller
@@ -39,4 +37,14 @@ class EmergencyController
         emergencyService.emit(emergency)
     }
 
+    @PostMapping(Paths.Emergency.ACCEPTED)
+    fun acceptEmergency(@RequestBody emergencyAccepted: EmergencyAcceptedDto): ResponseEntity<Unit> {
+        emergencyService.acceptEmergency(
+                emergencyId = emergencyAccepted.emergencyId,
+                helpProviderId = emergencyAccepted.helpProviderId
+        )
+
+        return ResponseEntity.accepted().build<Unit>()
+    }
+
 }

src/main/kotlin/org/oso/core/controllers/HelpProviderController.kt

@@ -47,16 +47,6 @@ class HelpProviderController
         }
     }
 
-    // TODO eventually move to emergency controller
-    @PostMapping(Paths.HelpProvider.ACCEPTED_EMERGENCY)
-    fun acceptEmergency(@RequestBody emergencyAccepted: EmergencyAcceptedDto): ResponseEntity<Unit> {
-        helpProviderService.acceptEmergency(
-            emergencyId = emergencyAccepted.emergencyId,
-            helpProviderId = emergencyAccepted.helpProviderId
-        )
-
-        return ResponseEntity.accepted().build<Unit>()
-    }
 
     private fun getHelpProviderOrFail(id: String): HelpProvider {
         return helpProviderService.findById(id) ?: throw HelpProviderNotFoundException("HelpProvider<$id> not found")
@@ -66,4 +56,5 @@ class HelpProviderController
         name = name,
         keycloakName = securityService.getCurrentUserName()
     )
+
 }

src/main/kotlin/org/oso/core/services/EmergencyService.kt

@@ -13,4 +13,5 @@ interface EmergencyService {
      * @param emergency The emergency containing relevant information
      */
     fun emit(emergency: Emergency)
+    fun acceptEmergency(emergencyId: String, helpProviderId: String)
 }

src/main/kotlin/org/oso/core/services/HelpProviderService.kt

@@ -8,5 +8,4 @@ interface HelpProviderService {
     fun findById(id: String): HelpProvider?
     fun findHelpRequesters(id: String): Set<HelpRequester>
     fun createHelpProvider(helpProvider: HelpProvider): HelpProvider
-    fun acceptEmergency(emergencyId: String, helpProviderId: String)
 }

src/main/kotlin/org/oso/core/services/impl/DefaultEmergencyService.kt

@@ -1,20 +1,27 @@
 package org.oso.core.services.impl
 
 import org.oso.core.entities.Emergency
+import org.oso.core.entities.EmergencyStatusType
 import org.oso.core.repositories.EmergencyRepository
 import org.oso.core.services.EmergencyService
+import org.oso.core.services.EmergencyStatusService
 import org.oso.core.services.external.NotificationService
 import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.stereotype.Service
 import org.springframework.web.bind.annotation.RequestBody
 import org.springframework.web.bind.annotation.ResponseBody
+import org.oso.core.repositories.HelpProviderRepository
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 
 @Service
 class DefaultEmergencyService
     @Autowired
     constructor(
         private val notificationService: NotificationService,
-        private val emergencyRepository: EmergencyRepository
+        private val emergencyRepository: EmergencyRepository,
+        private val emergencyStatusService: EmergencyStatusService,
+        private val helpProviderRepository: HelpProviderRepository
     ) : EmergencyService {
 
     override fun emit(emergency: Emergency) {
@@ -33,4 +40,54 @@ class DefaultEmergencyService
     override fun findEmergency(emergencyId: String): Emergency? {
         return emergencyRepository.findById(emergencyId).orElse(null)
     }
+
+    override fun acceptEmergency(emergencyId: String, helpProviderId: String) {
+        val emergency = findEmergency(emergencyId);
+        LOGGER.debug("emergency<$emergencyId> accepted by helpProvider<$helpProviderId>")
+
+        if (emergency == null) {
+            LOGGER.warn("emergency<$emergencyId> does not exist")
+            return
+        }
+
+        val helpProvider = helpProviderRepository.findById(helpProviderId).orElse(null)
+
+        if (helpProvider == null) {
+            LOGGER.warn("helpProvider<$helpProviderId> does not exist")
+            return
+        }
+
+        if (!helpProvider.isAssignedTo(emergency.helpRequester)) {
+            LOGGER.warn("helpProvider<$helpProviderId> is not assigned to helpRequester<${emergency.helpRequester.id}")
+            LOGGER.warn("helpProvider<$helpProviderId> is not allowed to accept emergency<$emergencyId> for helpresquester<${emergency.helpRequester.id}>")
+            return
+        }
+
+        emergencyStatusService.addStatus(emergency, helpProvider, EmergencyStatusType.TYPE_ACCEPTED)
+
+        if (!emergency.active) {
+            LOGGER.info("emergency<$emergencyId> is already resolved")
+            return
+        }
+        emergency.helpRequester.helpProviders
+                .filter { it.expoPushToken != null }
+                .filter { it.id != helpProviderId }
+                .map {
+                    notificationService.createEmergencyAcceptedPushNotification(
+                            to = it.expoPushToken!!,
+                            alarmID = emergencyId,
+                            helpRequesterId = emergency.helpRequester.id!!,
+                            helpProviderId = helpProviderId
+                    )
+                }
+                .let {
+                    if(!it.isEmpty()) {
+                        notificationService.sendPushNotification(it)
+                    }
+                }
+    }
+
+    companion object {
+        private val LOGGER: Logger = LoggerFactory.getLogger(DefaultEmergencyService::class.java)
+    }
 }

src/main/kotlin/org/oso/core/services/impl/DefaultHelpProviderService.kt

@@ -18,7 +18,6 @@ class DefaultHelpProviderService
     @Autowired
     constructor(
         private val notificationService: NotificationService,
-        private val emergencyStatusService: EmergencyStatusService,
         private val helpProviderRepository: HelpProviderRepository,
         private val emergencyService: EmergencyService
     ) : HelpProviderService {
@@ -39,53 +38,5 @@ class DefaultHelpProviderService
     override fun createHelpProvider(helpProvider: HelpProvider): HelpProvider =
         helpProviderRepository.save(helpProvider)
 
-    override fun acceptEmergency(emergencyId: String, helpProviderId: String) {
-        val emergency = emergencyService.findEmergency(emergencyId);
-        LOGGER.debug("emergency<$emergencyId> accepted by helpProvider<$helpProviderId>")
 
-        if (emergency == null) {
-            LOGGER.warn("emergency<$emergencyId> does not exist")
-            return
-        }
-
-        val helpProvider = helpProviderRepository.findById(helpProviderId).orElse(null)
-
-        if (helpProvider == null) {
-            LOGGER.warn("helpProvider<$helpProviderId> does not exist")
-            return
-        }
-
-        if (!helpProvider.isAssignedTo(emergency.helpRequester)) {
-            LOGGER.warn("helpProvider<$helpProviderId> is not assigned to helpRequester<${emergency.helpRequester.id}")
-            LOGGER.warn("helpProvider<$helpProviderId> is not allowed to accept emergency<$emergencyId> for helpresquester<${emergency.helpRequester.id}>")
-            return
-        }
-
-        emergencyStatusService.addStatus(emergency, helpProvider, EmergencyStatusType.TYPE_ACCEPTED)
-
-        if (!emergency.active) {
-            LOGGER.info("emergency<$emergencyId> is already resolved")
-            return
-        }
-        emergency.helpRequester.helpProviders
-            .filter { it.expoPushToken != null }
-            .filter { it.id != helpProviderId }
-            .map {
-                notificationService.createEmergencyAcceptedPushNotification(
-                        to = it.expoPushToken!!,
-                        alarmID = emergencyId,
-                        helpRequesterId = emergency.helpRequester.id!!,
-                        helpProviderId = helpProviderId
-                )
-            }
-            .let {
-                if(!it.isEmpty()) {
-                    notificationService.sendPushNotification(it)
-                }
-            }
-    }
-
-    companion object {
-        private val LOGGER: Logger = LoggerFactory.getLogger(DefaultHelpProviderService::class.java)
-    }
 }

src/test/kotlin/org/oso/core/controller/EmergencyControllerTest.kt

@@ -9,10 +9,12 @@ import org.mockito.Mockito
 import org.oso.any
 import org.oso.core.controllers.EmergencyController
 import org.oso.core.dtos.EmergencyDto
+import org.oso.core.dtos.EmergencyAcceptedDto
 import org.oso.core.entities.Emergency
 import org.oso.core.entities.EmergencyPriority
 import org.oso.core.entities.HelpRequester
 import org.oso.core.services.EmergencyService
+import org.oso.core.services.HelpProviderService
 import org.oso.core.services.HelpRequesterService
 import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.boot.test.autoconfigure.restdocs.AutoConfigureRestDocs
@@ -36,6 +38,9 @@ class EmergencyControllerTest {
     @MockBean
     lateinit var emergencyService: EmergencyService
 
+    @MockBean
+    lateinit var helpProviderService: HelpProviderService
+
     @MockBean
     lateinit var helpRequesterService: HelpRequesterService
 
@@ -112,4 +117,40 @@ class EmergencyControllerTest {
 //        // TODO test fails if helprequester is not given, as the helprequester-id will currently be defaulted to 0 which leads to HTTP 404 instead of 400
 //        testFailOnMissingParameters(mockMvc, "/${EmergencyController.PATH_EMERGENCY}/${EmergencyController.PATH_EMIT}", parameters)
     }
+
+    @Test
+    fun testAcceptEmergency() {
+        val dto = EmergencyAcceptedDto(
+                emergencyId = "25",
+                helpProviderId = "38",
+                helpRequesterId = "46"
+        )
+
+        Mockito.doNothing().`when`(emergencyService).acceptEmergency(dto.emergencyId, dto.helpProviderId)
+
+        this.mockMvc
+                .perform(
+                        MockMvcRequestBuilders
+                                .post("/${Paths.Emergency.ROOT}/${Paths.Emergency.ACCEPTED}")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .characterEncoding(StandardCharsets.UTF_8.name())
+                                .content(ObjectMapper().writeValueAsString(dto)))
+
+                .andExpect(MockMvcResultMatchers.status().isAccepted)
+                .andDo(MockMvcRestDocumentation.document("${Paths.Emergency.ROOT}/${Paths.Emergency.ACCEPTED}"))
+
+        Mockito.verify(emergencyService, Mockito.times(1)).acceptEmergency(dto.emergencyId, dto.helpProviderId)
+    }
+
+    @Test
+    fun `testAcceptEmergency throws exception on missing parameter`() {
+//        val parameters = listOf(
+//            "emergencyId" to "25",
+//            "helpProviderId" to "38",
+//            "helpRequesterId" to "46"
+//        )
+//
+//        // TODO this test always fails as jackson does not recognize the non-nullable parameters correclty
+//        testFailOnMissingParameters(mockMvc, "${HelpProviderController.PATH_HELP_PROVIDERS}/${HelpProviderController.PATH_ACCEPT_EMERGENCY}", parameters)
+    }
 }

src/test/kotlin/org/oso/core/controller/HelpProviderControllerTest.kt

@@ -11,7 +11,6 @@ import org.mockito.Mockito
 import org.oso.any
 import org.oso.config.Paths
 import org.oso.core.controllers.HelpProviderController
-import org.oso.core.dtos.EmergencyAcceptedDto
 import org.oso.core.dtos.HelpProviderPushDto
 import org.oso.core.entities.HelpProvider
 import org.oso.core.entities.HelpRequester
@@ -91,11 +90,6 @@ class HelpProviderControllerTest {
         val dto = HelpProviderPushDto(
             name = "HelpProvider"
         )
-        val helpProvider = HelpProvider(
-            id = "12345",
-            name = dto.name,
-            keycloakName = "keycloak12345"
-        )
 
         Mockito.`when`(helpProviderService.createHelpProvider(any())).thenThrow(IllegalArgumentException())
         //Mockito.doReturn(helpProvider).`when`(helpProviderService).createHelpProvider(ArgumentMatchers.any())
@@ -210,41 +204,7 @@ class HelpProviderControllerTest {
             .andExpect(MockMvcResultMatchers.status().isNotFound)
     }
 
-    @Test
-    fun testAcceptEmergency() {
-        val dto = EmergencyAcceptedDto(
-            emergencyId = "25",
-            helpProviderId = "38",
-            helpRequesterId = "46"
-        )
-
-        Mockito.doNothing().`when`(helpProviderService).acceptEmergency(dto.emergencyId, dto.helpProviderId)
 
-        this.mockMvc
-            .perform(
-                MockMvcRequestBuilders
-                    .post("/${Paths.HelpProvider.PROVIDERS}/${Paths.HelpProvider.ACCEPTED_EMERGENCY}")
-                    .contentType(MediaType.APPLICATION_JSON)
-                    .characterEncoding(StandardCharsets.UTF_8.name())
-                    .content(ObjectMapper().writeValueAsString(dto)))
-
-            .andExpect(MockMvcResultMatchers.status().isAccepted)
-            .andDo(MockMvcRestDocumentation.document("${Paths.HelpProvider.PROVIDERS}/${Paths.HelpProvider.ACCEPTED_EMERGENCY}"))
-
-        Mockito.verify(helpProviderService, Mockito.times(1)).acceptEmergency(dto.emergencyId, dto.helpProviderId)
-    }
-
-    @Test
-    fun `testAcceptEmergency throws exception on missing parameter`() {
-//        val parameters = listOf(
-//            "emergencyId" to "25",
-//            "helpProviderId" to "38",
-//            "helpRequesterId" to "46"
-//        )
-//
-//        // TODO this test always fails as jackson does not recognize the non-nullable parameters correclty
-//        testFailOnMissingParameters(mockMvc, "${HelpProviderController.PATH_HELP_PROVIDERS}/${HelpProviderController.PATH_ACCEPT_EMERGENCY}", parameters)
-    }
 
     companion object {
         private const val userName = "User"

src/test/kotlin/org/oso/core/controller/InvitationControllerTest.kt

@@ -70,7 +70,12 @@ class InvitationControllerTest {
                 MockMvcRequestBuilders
                         .get("/${Paths.Invitation.INVITATION}/${Paths.Invitation.ACCEPTED}?token=test123"))
             .andExpect(MockMvcResultMatchers.status().isOk)
-            .andExpect(MockMvcResultMatchers.content().string(Matchers.containsString("successful")))
+                .andExpect(MockMvcResultMatchers.content().string(
+                        Matchers.anyOf(
+                                Matchers.containsString("successfull"),
+                                Matchers.containsString("erfolgreich angenommen"))
+                )
+                )
 
         Assert.assertThat(hr.helpProviders, Matchers.iterableWithSize<HelpProvider>(1))
         Assert.assertThat(hr.helpProviders, Matchers.hasItem(hp))
@@ -90,7 +95,12 @@ class InvitationControllerTest {
                 MockMvcRequestBuilders
                         .get("/${Paths.Invitation.INVITATION}/${Paths.Invitation.ACCEPTED}?token=test123"))
                 .andExpect(MockMvcResultMatchers.status().isOk)
-                .andExpect(MockMvcResultMatchers.content().string(Matchers.containsString("expired")))
+                .andExpect(MockMvcResultMatchers.content().string(
+                        Matchers.anyOf(
+                                Matchers.containsString("expired"),
+                                Matchers.containsString("nicht mehr gültig"))
+                )
+                )
 
         Assert.assertThat(hr.helpProviders, Matchers.iterableWithSize<HelpProvider>(0))
         Assert.assertThat(hp.helpRequesters, Matchers.iterableWithSize<HelpRequester>(0))