Dev

review/src/main/kotlin/br/all/application/question/delete/DeleteQuestionPresenter.kt

@@ -0,0 +1,5 @@
+package br.all.application.question.delete
+
+import br.all.domain.shared.presenter.GenericPresenter
+
+interface DeleteQuestionPresenter : GenericPresenter<DeleteQuestionService.ResponseModel>

review/src/main/kotlin/br/all/application/question/delete/DeleteQuestionService.kt

@@ -0,0 +1,22 @@
+package br.all.application.question.delete
+
+import io.swagger.v3.oas.annotations.media.Schema
+import java.util.UUID
+
+interface DeleteQuestionService {
+    fun delete(presenter: DeleteQuestionPresenter, request: RequestModel)
+
+    data class RequestModel(
+        val userId: UUID,
+        val systematicStudyId: UUID,
+        val questionId: UUID,
+    )
+
+    @Schema(name = "DeleteQuestionResponseModel")
+    data class ResponseModel(
+        val userId: UUID,
+        val systematicStudyId: UUID,
+        val questionId: UUID,
+        val affectedStudyReviewIds: List<Long>
+    )
+}

review/src/main/kotlin/br/all/application/question/delete/DeleteQuestionServiceImpl.kt

@@ -0,0 +1,66 @@
+package br.all.application.question.delete
+
+import br.all.application.question.repository.QuestionRepository
+import br.all.application.review.repository.SystematicStudyRepository
+import br.all.application.review.repository.fromDto
+import br.all.application.shared.presenter.prepareIfFailsPreconditions
+import br.all.application.study.repository.StudyReviewRepository
+import br.all.application.user.CredentialsService
+import br.all.domain.model.question.QuestionId
+import br.all.domain.model.review.SystematicStudy
+import org.springframework.stereotype.Service
+
+@Service
+class DeleteQuestionServiceImpl(
+    private val systematicStudyRepository: SystematicStudyRepository,
+    private val questionRepository: QuestionRepository,
+    private val credentialsService: CredentialsService,
+    private val studyReviewRepository: StudyReviewRepository,
+) : DeleteQuestionService {
+    override fun delete(presenter: DeleteQuestionPresenter, request: DeleteQuestionService.RequestModel) {
+        val systematicStudyId = request.systematicStudyId
+        val userId = request.userId
+
+        val user = credentialsService.loadCredentials(userId)?.toUser()
+        val systematicStudyDto = systematicStudyRepository.findById(systematicStudyId)
+        val systematicStudy = systematicStudyDto?.let { SystematicStudy.fromDto(it) }
+
+        presenter.prepareIfFailsPreconditions(user, systematicStudy)
+        if (presenter.isDone()) return
+
+        val questionId = QuestionId(request.questionId)
+        val question = questionRepository.findById(systematicStudyId, questionId.value)
+        if (question == null) {
+            presenter.prepareFailView(NoSuchElementException("Question with id ${questionId.value} not found for study $systematicStudyId."))
+            return
+        }
+
+        val affectedStudyReviewIds = mutableListOf<Long>()
+
+        try {
+            questionRepository.deleteById(systematicStudyId, questionId.value)
+
+            val studyReviews = studyReviewRepository.findAllFromReview(systematicStudyId)
+            studyReviews.forEach { review ->
+                val updatedFormAnswers = review.formAnswers.filterNot { it.key == questionId.value }
+                val updatedRobAnswers = review.robAnswers.filterNot { it.key == questionId.value }
+
+                if (updatedFormAnswers != review.formAnswers || updatedRobAnswers != review.robAnswers) {
+                    val updatedReview = review.copy(
+                        formAnswers = updatedFormAnswers,
+                        robAnswers = updatedRobAnswers,
+                    )
+
+                    studyReviewRepository.saveOrUpdate(updatedReview)
+                    affectedStudyReviewIds.add(review.studyReviewId)
+                }
+            }
+
+        } catch (e: Exception) {
+            presenter.prepareFailView(e)
+            return
+        }
+
+        presenter.prepareSuccessView(DeleteQuestionService.ResponseModel(userId, systematicStudyId, question.questionId, affectedStudyReviewIds))
+    }
+}

review/src/main/kotlin/br/all/application/question/repository/QuestionRepository.kt

@@ -7,4 +7,5 @@ interface QuestionRepository {
     fun createOrUpdate(dto: QuestionDto)
     fun findById(systematicStudyId: UUID, id: UUID): QuestionDto?
     fun findAllBySystematicStudyId(systematicStudyId: UUID, context: QuestionContextEnum? = null): List<QuestionDto>
+    fun deleteById(systematicStudyId: UUID, id: UUID)
 }

review/src/main/kotlin/br/all/application/study/find/presenter/FindAllIncludedStudyReviewsPresenter.kt

@@ -0,0 +1,6 @@
+package br.all.application.study.find.presenter
+
+import br.all.application.study.find.service.FindAllIncludedStudyReviewsService.ResponseModel
+import br.all.domain.shared.presenter.GenericPresenter
+
+interface FindAllIncludedStudyReviewsPresenter : GenericPresenter<ResponseModel>

review/src/main/kotlin/br/all/application/study/find/presenter/FindAllStudyReviewsByAdvancedSearchPresenter.kt

@@ -0,0 +1,6 @@
+package br.all.application.study.find.presenter
+
+import br.all.application.study.find.service.FindAllStudyReviewsByAdvancedSearchService.ResponseModel
+import br.all.domain.shared.presenter.GenericPresenter
+
+interface FindAllStudyReviewsByAdvancedSearchPresenter : GenericPresenter<ResponseModel>

review/src/main/kotlin/br/all/application/study/find/service/FindAllIncludedStudyReviewsService.kt

@@ -0,0 +1,30 @@
+package br.all.application.study.find.service
+
+import br.all.application.study.find.presenter.FindAllIncludedStudyReviewsPresenter
+import br.all.application.study.repository.StudyReviewDto
+import io.swagger.v3.oas.annotations.media.Schema
+import java.util.UUID
+
+interface FindAllIncludedStudyReviewsService {
+
+    fun findAllIncluded(presenter: FindAllIncludedStudyReviewsPresenter, request: RequestModel)
+
+    data class RequestModel(
+        val userId: UUID,
+        val systematicStudyId: UUID,
+        val page: Int = 0,
+        val pageSize: Int = 20,
+        val sort: String = "id,asc"
+    )
+
+    @Schema(name = "FindAllIncludedStudyReviewsResponseModel")
+    data class ResponseModel(
+        val userId: UUID,
+        val systematicStudyId: UUID,
+        val studyReviews: List<StudyReviewDto>,
+        val page: Int,
+        val size: Int,
+        val totalElements: Long,
+        val totalPages: Int
+    )
+}

review/src/main/kotlin/br/all/application/study/find/service/FindAllIncludedStudyReviewsServiceImpl.kt

@@ -0,0 +1,70 @@
+package br.all.application.study.find.service
+
+import br.all.application.review.repository.SystematicStudyRepository
+import br.all.application.review.repository.fromDto
+import br.all.application.shared.presenter.prepareIfFailsPreconditions
+import br.all.application.study.find.presenter.FindAllIncludedStudyReviewsPresenter
+import br.all.application.study.repository.StudyReviewRepository
+import br.all.application.user.CredentialsService
+import br.all.domain.model.review.SystematicStudy
+import br.all.domain.model.study.SelectionStatus
+import org.springframework.data.domain.PageRequest
+import org.springframework.data.domain.Sort
+
+class FindAllIncludedStudyReviewsServiceImpl(
+    private val systematicStudyRepository: SystematicStudyRepository,
+    private val studyReviewRepository: StudyReviewRepository,
+    private val credentialsService: CredentialsService,
+) : FindAllIncludedStudyReviewsService {
+
+    private fun parseSortParameter(sortParam: String): Sort {
+        val parts = sortParam.split(",")
+        val property = parts[0]
+        val direction = if (parts.size > 1 && parts[1].equals("desc", ignoreCase = true)) {
+            Sort.Direction.DESC
+        } else {
+            Sort.Direction.ASC
+        }
+        return Sort.by(direction, property)
+    }
+
+    override fun findAllIncluded(
+        presenter: FindAllIncludedStudyReviewsPresenter,
+        request: FindAllIncludedStudyReviewsService.RequestModel
+    ) {
+        val user = credentialsService.loadCredentials(request.userId)?.toUser()
+
+        val systematicStudyDto = systematicStudyRepository.findById(request.systematicStudyId)
+        val systematicStudy = systematicStudyDto?.let { SystematicStudy.fromDto(it) }
+
+        presenter.prepareIfFailsPreconditions(user, systematicStudy)
+
+        if (presenter.isDone()) return
+
+        val sort = parseSortParameter(request.sort)
+        val pageable = PageRequest.of(
+            request.page,
+            request.pageSize,
+            sort
+        )
+
+        val studyReviewsPage = studyReviewRepository.findAllBySystematicStudyIdAndSelectionStatusPaged(
+            request.systematicStudyId,
+            SelectionStatus.INCLUDED,
+            pageable
+        )
+
+        presenter.prepareSuccessView(
+            FindAllIncludedStudyReviewsService.ResponseModel(
+                userId = request.userId,
+                systematicStudyId = request.systematicStudyId,
+                studyReviews = studyReviewsPage.content,
+                page = pageable.pageNumber,
+                size = pageable.pageSize,
+                totalElements = studyReviewsPage.totalElements,
+                totalPages = studyReviewsPage.totalPages
+            )
+        )
+    }
+
+}

review/src/main/kotlin/br/all/application/study/find/service/FindAllStudyReviewsByAdvancedSearchService.kt

@@ -0,0 +1,40 @@
+package br.all.application.study.find.service
+
+import br.all.application.study.find.presenter.FindAllStudyReviewsByAdvancedSearchPresenter
+import br.all.application.study.repository.StudyReviewDto
+import io.swagger.v3.oas.annotations.media.Schema
+import java.util.*
+
+interface FindAllStudyReviewsByAdvancedSearchService {
+
+    fun findAllByAdvancedSearch(presenter: FindAllStudyReviewsByAdvancedSearchPresenter, request: RequestModel)
+
+    data class RequestModel(
+        val userId: UUID,
+        val systematicStudyId: UUID,
+        val id: Long? = null,
+        val studyReviewId: String? = null,
+        val title: String? = null,
+        val authors: String? = null,
+        val venue: String? = null,
+        val year: Int? = null,
+        val selectionStatus: String? = null,
+        val extractionStatus: String? = null,
+        val score: Double? = null,
+        val readingPriority: Int? = null,
+        val page: Int = 0,
+        val pageSize: Int = 20,
+        val sort: String = "id,asc"
+    )
+
+    @Schema(name = "FindAllStudyReviewsByAdvancedSearchResponseModel")
+    data class ResponseModel(
+        val userId: UUID,
+        val systematicStudyId: UUID,
+        val studyReviews: List<StudyReviewDto>,
+        val page: Int,
+        val size: Int,
+        val totalElements: Long,
+        val totalPages: Int
+    )
+}

review/src/main/kotlin/br/all/application/study/find/service/FindAllStudyReviewsByAdvancedSearchServiceImpl.kt

@@ -0,0 +1,73 @@
+package br.all.application.study.find.service
+
+import br.all.application.review.repository.SystematicStudyRepository
+import br.all.application.review.repository.fromDto
+import br.all.application.shared.presenter.prepareIfFailsPreconditions
+import br.all.application.study.find.presenter.FindAllStudyReviewsByAdvancedSearchPresenter
+import br.all.application.study.repository.StudyReviewRepository
+import br.all.application.user.CredentialsService
+import br.all.domain.model.review.SystematicStudy
+import org.springframework.data.domain.PageRequest
+import org.springframework.data.domain.Sort
+
+class FindAllStudyReviewsByAdvancedSearchServiceImpl(
+    private val systematicStudyRepository: SystematicStudyRepository,
+    private val studyReviewRepository: StudyReviewRepository,
+    private val credentialsService: CredentialsService
+) : FindAllStudyReviewsByAdvancedSearchService {
+
+    private fun parseSortParameter(sortParam: String): Sort {
+        val parts = sortParam.split(",")
+        val property = parts[0]
+        val direction = if (parts.size > 1 && parts[1].equals("desc", ignoreCase = true)) {
+            Sort.Direction.DESC
+        } else Sort.Direction.ASC
+        return Sort.by(direction, property)
+    }
+
+    override fun findAllByAdvancedSearch(
+        presenter: FindAllStudyReviewsByAdvancedSearchPresenter,
+        request: FindAllStudyReviewsByAdvancedSearchService.RequestModel
+    ) {
+        val user = credentialsService.loadCredentials(request.userId)?.toUser()
+        val systematicStudyDto = systematicStudyRepository.findById(request.systematicStudyId)
+        val systematicStudy = systematicStudyDto?.let { SystematicStudy.fromDto(it) }
+
+        presenter.prepareIfFailsPreconditions(user, systematicStudy)
+        if (presenter.isDone()) return
+
+        val sort = parseSortParameter(request.sort)
+        val pageable = PageRequest.of(request.page, request.pageSize, sort)
+
+        val filters = mapOf(
+            "id" to request.id,
+            "studyReviewId" to request.studyReviewId,
+            "title" to request.title,
+            "authors" to request.authors,
+            "venue" to request.venue,
+            "year" to request.year,
+            "selectionStatus" to request.selectionStatus,
+            "extractionStatus" to request.extractionStatus,
+            "score" to request.score,
+            "readingPriority" to request.readingPriority
+        )
+
+        val pageResult = studyReviewRepository.findAllByAdvancedSearch(
+            reviewId = request.systematicStudyId,
+            filters = filters,
+            pageable = pageable
+        )
+
+        presenter.prepareSuccessView(
+            FindAllStudyReviewsByAdvancedSearchService.ResponseModel(
+                userId = request.userId,
+                systematicStudyId = request.systematicStudyId,
+                studyReviews = pageResult.content,
+                page = pageable.pageNumber,
+                size = pageable.pageSize,
+                totalElements = pageResult.totalElements,
+                totalPages = pageResult.totalPages
+            )
+        )
+    }
+}

review/src/main/kotlin/br/all/application/study/find/service/FindAllStudyReviewsBySessionService.kt

@@ -13,12 +13,20 @@ interface FindAllStudyReviewsBySessionService {
         val userId: UUID,
         val systematicStudyId: UUID,
         val searchSessionId: UUID,
+        val page: Int = 0,
+        val pageSize: Int = 20,
+        val sort: String = "id,asc"
     )
+
     @Schema(name = "FindAllStudyReviewsBySessionResponseModel")
     data class ResponseModel(
         val userId: UUID,
         val systematicStudyId: UUID,
         val searchSessionId: UUID,
-        val studyReviews: List<StudyReviewDto>
+        val studyReviews: List<StudyReviewDto>,
+        val page: Int,
+        val size: Int,
+        val totalElements: Long,
+        val totalPages: Int
     )
 }