Merge pull request #6493 from espoon-voltti/linkity-enable-for-units

Toimintojen avauksien huomioiminen Linkity-integraatiossa

Author: terolaakso

service/src/integrationTest/kotlin/fi/espoo/evaka/linkity/LinkityServiceTest.kt

@@ -7,23 +7,46 @@ package fi.espoo.evaka.linkity
 import fi.espoo.evaka.FullApplicationTest
 import fi.espoo.evaka.attendance.*
 import fi.espoo.evaka.shared.GroupId
+import fi.espoo.evaka.shared.auth.UserRole
+import fi.espoo.evaka.shared.auth.insertDaycareAclRow
 import fi.espoo.evaka.shared.db.Database
 import fi.espoo.evaka.shared.dev.*
 import fi.espoo.evaka.shared.domain.FiniteDateRange
 import fi.espoo.evaka.shared.domain.HelsinkiDateTime
+import fi.espoo.evaka.shared.security.PilotFeature
 import java.time.LocalDate
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
+import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 
 internal class LinkityServiceTest : FullApplicationTest(resetDbBeforeEach = true) {
+    val employeeNumber = "SARASTIA_1"
+    lateinit var employee: DevEmployee
+    lateinit var area: DevCareArea
+    lateinit var daycare: DevDaycare
+
+    @BeforeEach
+    fun beforeEach() {
+        employee = DevEmployee(employeeNumber = employeeNumber)
+        area = DevCareArea()
+        daycare =
+            DevDaycare(
+                areaId = area.id,
+                enabledPilotFeatures = setOf(PilotFeature.STAFF_ATTENDANCE_INTEGRATION),
+            )
+        db.transaction { tx ->
+            tx.insert(area)
+            tx.insert(daycare)
+            tx.insert(employee)
+            tx.insertDaycareAclRow(daycare.id, employee.id, UserRole.STAFF)
+        }
+    }
+
     @Test
     fun `new plans from Linkity replace old plans`() {
         val today = LocalDate.now()
-        val employeeNumber = "SARASTIA_1"
-        val employee = DevEmployee(employeeNumber = employeeNumber)
         db.transaction { tx ->
-            tx.insert(employee)
             tx.insertStaffAttendancePlans(
                 sequenceOf(-1, 0, 1, 2)
                     .map { days ->
@@ -67,9 +90,6 @@ internal class LinkityServiceTest : FullApplicationTest(resetDbBeforeEach = true
     @Test
     fun `new plans with unknown sarastia id are ignored`() {
         val today = LocalDate.now()
-        val employeeNumber = "SARASTIA_2"
-        val employee = DevEmployee(employeeNumber = employeeNumber)
-        db.transaction { tx -> tx.insert(employee) }
         val period = FiniteDateRange(today, today.plusDays(1))
         val shifts =
             listOf(
@@ -93,9 +113,6 @@ internal class LinkityServiceTest : FullApplicationTest(resetDbBeforeEach = true
     @Test
     fun `new plans with invalid times are ignored`() {
         val today = LocalDate.now()
-        val employeeNumber = "SARASTIA_3"
-        val employee = DevEmployee(employeeNumber = employeeNumber)
-        db.transaction { tx -> tx.insert(employee) }
         val period = FiniteDateRange(today, today.plusDays(1))
         val shifts =
             listOf(
@@ -119,9 +136,6 @@ internal class LinkityServiceTest : FullApplicationTest(resetDbBeforeEach = true
     @Test
     fun `new plans with overlapping times are ignored`() {
         val today = LocalDate.now()
-        val employeeNumber = "SARASTIA_4"
-        val employee = DevEmployee(employeeNumber = employeeNumber)
-        db.transaction { tx -> tx.insert(employee) }
         val period = FiniteDateRange(today, today.plusDays(1))
         val shifts =
             listOf(
@@ -151,6 +165,37 @@ internal class LinkityServiceTest : FullApplicationTest(resetDbBeforeEach = true
         assertTrue { plans.any { it.description == "Uusi" && it.startTime.hour == 8 } }
     }
 
+    @Test
+    fun `new plans for employees in disabled daycares are ignored`() {
+        val today = LocalDate.now()
+        val employeeNumber2 = "SARASTIA_2"
+        val employee2 = DevEmployee(employeeNumber = employeeNumber2)
+        val daycare2 = DevDaycare(areaId = area.id, enabledPilotFeatures = setOf())
+        db.transaction { tx ->
+            tx.insert(daycare2)
+            tx.insert(employee2)
+            tx.insertDaycareAclRow(daycare2.id, employee2.id, UserRole.STAFF)
+        }
+        val period = FiniteDateRange(today, today.plusDays(1))
+        val shifts =
+            listOf(
+                Shift(
+                    employeeNumber2,
+                    "WORK_SHIFT_1",
+                    HelsinkiDateTime.of(today.atTime(8, 0)),
+                    HelsinkiDateTime.of(today.atTime(16, 0)),
+                    ShiftType.PRESENT,
+                    "Uusi",
+                )
+            )
+        val client = MockLinkityClient(shifts)
+        updateStaffAttendancePlansFromLinkity(period, db, client)
+
+        val plans = db.transaction { tx -> tx.findStaffAttendancePlansBy() }
+        // There will be no plans
+        assertEquals(0, plans.size)
+    }
+
     private fun upsertStaffAttendance(
         tx: Database.Transaction,
         employee: DevEmployee,
@@ -176,18 +221,19 @@ internal class LinkityServiceTest : FullApplicationTest(resetDbBeforeEach = true
     @Test
     fun `relevant attendances are sent to Linkity`() {
         val now = HelsinkiDateTime.now()
-        val employeeNumber = "SARASTIA_1"
         db.transaction { tx ->
-            val area = DevCareArea()
-            val unit = DevDaycare(areaId = area.id)
-            val group = DevDaycareGroup(daycareId = unit.id)
-            val employee = DevEmployee(employeeNumber = employeeNumber)
-            val employee2 = DevEmployee(employeeNumber = null)
-            tx.insert(area)
-            tx.insert(unit)
+            val group = DevDaycareGroup(daycareId = daycare.id)
+            val employee2 = DevEmployee(employeeNumber = "SARASTIA_2")
+            val employee3 = DevEmployee(employeeNumber = null)
+            val daycare2 = DevDaycare(areaId = area.id, enabledPilotFeatures = setOf())
+            val group2 = DevDaycareGroup(daycareId = daycare2.id)
+            tx.insert(daycare2)
             tx.insert(group)
-            tx.insert(employee)
+            tx.insert(group2)
             tx.insert(employee2)
+            tx.insert(employee3)
+            tx.insertDaycareAclRow(daycare2.id, employee2.id, UserRole.STAFF)
+            tx.insertDaycareAclRow(daycare.id, employee3.id, UserRole.STAFF)
             tx.insertStaffAttendancePlans(
                 listOf(
                     StaffAttendancePlan(
@@ -270,12 +316,21 @@ internal class LinkityServiceTest : FullApplicationTest(resetDbBeforeEach = true
             // 7th
             upsertStaffAttendance(
                 tx,
-                employee2,
+                employee3,
                 group.id,
                 now.minusHours(4),
                 now.minusHours(3),
                 StaffAttendanceType.PRESENT,
             )
+            // 8th
+            upsertStaffAttendance(
+                tx,
+                employee2,
+                group2.id,
+                now.minusHours(5),
+                now.minusHours(4),
+                StaffAttendanceType.PRESENT,
+            )
         }
         val period = FiniteDateRange(now.minusDays(1).toLocalDate(), now.toLocalDate())
 
@@ -316,6 +371,7 @@ internal class LinkityServiceTest : FullApplicationTest(resetDbBeforeEach = true
                 ),
                 // 6th attendance is not included because it has not ended yet
                 // 7th attendance is not included because the employee has no employee number
+                // 8th attendance is not included because the employee is not in an enabled daycare
             )
 
         assertEquals(expected, client.getPreviouslyPostedWorkLogs().toSet())

service/src/main/kotlin/fi/espoo/evaka/linkity/LinkityQueries.kt

@@ -18,7 +18,9 @@ data class ExportableAttendance(
     val sarastiaId: String,
 )
 
-fun Database.Read.getStaffAttendances(range: FiniteDateRange): List<ExportableAttendance> {
+fun Database.Read.getStaffAttendancesForEnabledDaycares(
+    range: FiniteDateRange
+): List<ExportableAttendance> {
     return createQuery {
             sql(
                 """ 
@@ -30,9 +32,38 @@ SELECT
     emp.employee_number as sarastia_id
 FROM staff_attendance_realtime sa
 JOIN employee emp ON sa.employee_id = emp.id
-WHERE emp.employee_number IS NOT NULL AND ${bind(range.asHelsinkiDateTimeRange())} @> arrived and departed IS NOT NULL
+WHERE emp.employee_number IS NOT NULL 
+    AND ${bind(range.asHelsinkiDateTimeRange())} @> arrived 
+    AND departed IS NOT NULL
+    AND EXISTS (
+        SELECT
+        FROM daycare_acl acl
+        JOIN daycare d ON acl.daycare_id = d.id
+        WHERE acl.employee_id = emp.id AND 'STAFF_ATTENDANCE_INTEGRATION' = ANY(d.enabled_pilot_features)
+    )
 """
             )
         }
         .toList()
 }
+
+fun Database.Read.getEmployeeIdsForEnabledDaycares(
+    employeeNumbers: Collection<String>
+): Map<String, EmployeeId> {
+    return createQuery {
+            sql(
+                """
+SELECT id, employee_number
+FROM employee e
+WHERE employee_number = ANY (${bind(employeeNumbers)})
+    AND EXISTS (
+        SELECT
+        FROM daycare_acl acl
+        JOIN daycare d ON acl.daycare_id = d.id
+        WHERE acl.employee_id = e.id AND 'STAFF_ATTENDANCE_INTEGRATION' = ANY(d.enabled_pilot_features)
+    )
+            """
+            )
+        }
+        .toMap { columnPair("employee_number", "id") }
+}

service/src/main/kotlin/fi/espoo/evaka/linkity/LinkityService.kt

@@ -8,7 +8,6 @@ import com.fasterxml.jackson.databind.json.JsonMapper
 import fi.espoo.evaka.LinkityEnv
 import fi.espoo.evaka.attendance.*
 import fi.espoo.evaka.espoo.EspooAsyncJob
-import fi.espoo.evaka.pis.getEmployeeIdsByNumbers
 import fi.espoo.evaka.shared.EmployeeId
 import fi.espoo.evaka.shared.db.Database
 import fi.espoo.evaka.shared.domain.EvakaClock
@@ -58,7 +57,7 @@ fun updateStaffAttendancePlansFromLinkity(
     val sarastiaIds = linkityShifts.map { it.sarastiaId }.toSet()
 
     db.transaction { tx ->
-        val sarastiaIdToEmployeeId = tx.getEmployeeIdsByNumbers(sarastiaIds)
+        val sarastiaIdToEmployeeId = tx.getEmployeeIdsForEnabledDaycares(sarastiaIds)
 
         val shifts = filterValidShifts(linkityShifts, sarastiaIdToEmployeeId)
 
@@ -93,7 +92,7 @@ private fun filterValidShifts(
         shifts.partition { sarastiaIdToEmployeeId.containsKey(it.sarastiaId) }
     if (withUnknownSarastiaId.isNotEmpty()) {
         logger.info {
-            "No employee found for Sarastia IDs: ${withUnknownSarastiaId.map { it.sarastiaId }}"
+            "No employee found from any enabled daycare for Sarastia IDs: ${withUnknownSarastiaId.map { it.sarastiaId }}"
         }
     }
     val (validTimesShifts, invalidTimesShifts) =
@@ -124,7 +123,7 @@ fun sendStaffAttendancesToLinkity(
     lateinit var plans: Map<EmployeeId, List<StaffAttendancePlan>>
 
     db.transaction { tx ->
-        attendances = tx.getStaffAttendances(period).groupBy { it.employeeId }
+        attendances = tx.getStaffAttendancesForEnabledDaycares(period).groupBy { it.employeeId }
         val employeeIds = attendances.keys
         plans =
             tx.findStaffAttendancePlansBy(period = period, employeeIds = employeeIds).groupBy {