1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
/*
* This file is part of ETL-Processor
*
* Copyright (c) 2023 Comprehensive Cancer Center Mainfranken
* Copyright (c) 2023-2026 Paul-Christian Volkmer, Datenintegrationszentrum Philipps-Universität Marburg and Contributors
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published
* by the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package dev.dnpm.etl.processor.services
import dev.dnpm.etl.processor.PatientPseudonym
import dev.dnpm.etl.processor.RequestId
import dev.dnpm.etl.processor.Tan
import dev.dnpm.etl.processor.monitoring.*
import dev.dnpm.etl.processor.toPage
import org.springframework.data.domain.Page
import org.springframework.data.domain.Pageable
import org.springframework.stereotype.Service
import java.util.*
@Service
class RequestService(private val requestRepository: RequestRepository) {
fun save(request: Request) = requestRepository.save(request)
fun findAll(): Iterable<Request> = requestRepository.findAll()
fun findAll(pageable: Pageable): Page<Request> = requestRepository.findAll(pageable)
fun searchRequestLike(patientPseudonym: PatientPseudonym, tan: Tan, pageable: Pageable): Page<Request> =
requestRepository.findByPatientPseudonymContainingIgnoreCaseOrTanContainingIgnoreCase(patientPseudonym, tan, pageable)
fun searchRequestLike(patientPseudonym: PatientPseudonym, tan: Tan): List<Request> =
requestRepository.findByPatientPseudonymContainingIgnoreCaseOrTanContainingIgnoreCase(patientPseudonym, tan)
fun findByUuid(uuid: RequestId): Optional<Request> = requestRepository.findByUuidEquals(uuid)
fun findRequestByPatientId(
patientPseudonym: PatientPseudonym,
pageable: Pageable,
): Page<Request> = requestRepository.findRequestByPatientPseudonym(patientPseudonym, pageable)
fun allRequestsByPatientPseudonym(patientPseudonym: PatientPseudonym) =
requestRepository.findAllByPatientPseudonymOrderByProcessedAtDesc(patientPseudonym)
fun lastMtbFileRequestForPatientPseudonym(patientPseudonym: PatientPseudonym) =
Companion.lastMtbFileRequestForPatientPseudonym(
allRequestsByPatientPseudonym(patientPseudonym)
)
fun isLastRequestWithKnownStatusDeletion(patientPseudonym: PatientPseudonym) =
Companion.isLastRequestWithKnownStatusDeletion(
allRequestsByPatientPseudonym(patientPseudonym)
)
fun countStates(): Iterable<CountedState> = requestRepository.countStates()
fun countDeleteStates(): Iterable<CountedState> = requestRepository.countDeleteStates()
fun findPatientUniqueStates(): List<CountedState> = requestRepository.findPatientUniqueStates()
fun findPatientUniqueDeleteStates(): List<CountedState> =
requestRepository.findPatientUniqueDeleteStates()
companion object {
fun lastMtbFileRequestForPatientPseudonym(allRequests: List<Request>) =
allRequests
.filter { it.type == RequestType.MTB_FILE }
.sortedByDescending { it.processedAt }
.firstOrNull {
it.status == RequestStatus.SUCCESS || it.status == RequestStatus.WARNING
}
fun isLastRequestWithKnownStatusDeletion(allRequests: List<Request>) =
allRequests
.filter { it.status != RequestStatus.UNKNOWN }
.maxByOrNull { it.processedAt }
?.type == RequestType.DELETE
}
enum class Filter(val value: String) {
ALL_DIP("all-dip"),
CONFIRMED("confirmed"),
UNCONFIRMED("unconfirmed");
}
}
fun List<Request>.filter(filter: RequestService.Filter, pageable: Pageable): Page<Request> {
return this
.toList()
.sortedByDescending { it.processedAt }
.filter {
it.type == RequestType.MTB_FILE
&& sequenceOf(RequestStatus.SUCCESS, RequestStatus.WARNING).contains(it.status)
}
.filter {
filter == RequestService.Filter.ALL_DIP
|| filter == RequestService.Filter.CONFIRMED && it.submissionAccepted
|| filter == RequestService.Filter.UNCONFIRMED && !it.submissionAccepted
}
.toPage(pageable)
}
|
