Acessar servicos de assitencia

.gitignore

@@ -34,7 +34,7 @@ out/
 /dist/
 /nbdist/
 /.nb-gradle/
-
+data/
 ### VS Code ###
 .vscode/
 

data/myDB.trace.db

@@ -0,0 +1,38 @@
+2025-05-20 12:36:33.423212Z jdbc[3]: exception
+java.sql.SQLClientInfoException: Client info name 'ApplicationName' not supported.
+	at org.h2.jdbc.JdbcConnection.setClientInfo(JdbcConnection.java:1624)
+	at com.intellij.database.remote.jdbc.impl.RemoteConnectionImpl.setClientInfo(RemoteConnectionImpl.java:468)
+	at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:103)
+	at java.base/java.lang.reflect.Method.invoke(Method.java:580)
+	at java.rmi/sun.rmi.server.UnicastServerRef.dispatch(UnicastServerRef.java:360)
+	at java.rmi/sun.rmi.transport.Transport$1.run(Transport.java:200)
+	at java.rmi/sun.rmi.transport.Transport$1.run(Transport.java:197)
+	at java.base/java.security.AccessController.doPrivileged(AccessController.java:714)
+	at java.rmi/sun.rmi.transport.Transport.serviceCall(Transport.java:196)
+	at java.rmi/sun.rmi.transport.tcp.TCPTransport.handleMessages(TCPTransport.java:598)
+	at java.rmi/sun.rmi.transport.tcp.TCPTransport$ConnectionHandler.run0(TCPTransport.java:844)
+	at java.rmi/sun.rmi.transport.tcp.TCPTransport$ConnectionHandler.lambda$run$0(TCPTransport.java:721)
+	at java.base/java.security.AccessController.doPrivileged(AccessController.java:400)
+	at java.rmi/sun.rmi.transport.tcp.TCPTransport$ConnectionHandler.run(TCPTransport.java:720)
+	at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1144)
+	at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:642)
+	at java.base/java.lang.Thread.run(Thread.java:1583)
+2025-05-20 12:36:34.044132Z jdbc[3]: exception
+java.sql.SQLClientInfoException: Client info name 'ApplicationName' not supported.
+	at org.h2.jdbc.JdbcConnection.setClientInfo(JdbcConnection.java:1624)
+	at com.intellij.database.remote.jdbc.impl.RemoteConnectionImpl.setClientInfo(RemoteConnectionImpl.java:468)
+	at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:103)
+	at java.base/java.lang.reflect.Method.invoke(Method.java:580)
+	at java.rmi/sun.rmi.server.UnicastServerRef.dispatch(UnicastServerRef.java:360)
+	at java.rmi/sun.rmi.transport.Transport$1.run(Transport.java:200)
+	at java.rmi/sun.rmi.transport.Transport$1.run(Transport.java:197)
+	at java.base/java.security.AccessController.doPrivileged(AccessController.java:714)
+	at java.rmi/sun.rmi.transport.Transport.serviceCall(Transport.java:196)
+	at java.rmi/sun.rmi.transport.tcp.TCPTransport.handleMessages(TCPTransport.java:598)
+	at java.rmi/sun.rmi.transport.tcp.TCPTransport$ConnectionHandler.run0(TCPTransport.java:844)
+	at java.rmi/sun.rmi.transport.tcp.TCPTransport$ConnectionHandler.lambda$run$0(TCPTransport.java:721)
+	at java.base/java.security.AccessController.doPrivileged(AccessController.java:400)
+	at java.rmi/sun.rmi.transport.tcp.TCPTransport$ConnectionHandler.run(TCPTransport.java:720)
+	at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1144)
+	at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:642)
+	at java.base/java.lang.Thread.run(Thread.java:1583)

src/main/kotlin/ufrpe/sbpc/botpcd/entity/MessageExchange.kt

@@ -18,6 +18,5 @@ class MessageExchange(
     @Column(columnDefinition = "TEXT")
     var message: String
 ) {
-    @CreationTimestamp
-    lateinit var createAt: LocalDateTime
+     var createAt: LocalDateTime = LocalDateTime.now()
 }

src/main/kotlin/ufrpe/sbpc/botpcd/entity/PWD.kt

@@ -27,5 +27,5 @@ class PWD(
     @CollectionTable(name = "tb_pwd_disabilities", joinColumns = [JoinColumn(name = "pwd_id")])
     @Column(name = "disability")
     @Enumerated(EnumType.STRING)
-    var disabilities: MutableSet<Disability> = mutableSetOf()
+    var disabilities: Set<Disability> = setOf()
 ): User(name = name, phoneNumber = phoneNumber)

src/main/kotlin/ufrpe/sbpc/botpcd/entity/ServiceType.kt

@@ -51,7 +51,7 @@ sealed class ServiceType(
 
     object HygieneAndNutrition : ServiceType(
         attendantType = Provider.COMMITTEE_MEMBER,
-        disability = mutableSetOf(Disability.MOBILITY_IMPAIRED, Disability.PHYSICAL_DISABILITY),
+        disability = mutableSetOf(Disability.PHYSICAL_DISABILITY),
         description = "ajuda com alimentação e higiene"
     )
 
@@ -66,11 +66,24 @@ sealed class ServiceType(
         fun getServicesByDisability(disability: Disability): List<ServiceType> {
             return ServiceType::class.sealedSubclasses
                 .mapNotNull { it.objectInstance }
-                .filter { disability in it.disability }
+                .filter { disability in it.disability }.sortedBy { it.description.getAlphabeticOrder() }
+        }
+        fun getServiceByMonitorAssistanceType(monitorAssistanceType: MonitorAssistanceType): ServiceType {
+            return ServiceType::class.sealedSubclasses
+                .mapNotNull { it.objectInstance }
+                .filterIsInstance<MonitorServiceType>()
+                .first { it.monitorAssistanceType == monitorAssistanceType } as ServiceType
+        }
+        fun getByDescription(description: String): ServiceType {
+            return ServiceType::class.sealedSubclasses
+                .mapNotNull { it.objectInstance }
+                .first { it.description == description } as ServiceType
         }
-
     }
 }
+
+fun String.getAlphabeticOrder() = this.replace("[^a-zA-Z]".toRegex(), "").slice(0..9).reduce {prev, curr -> prev + curr.code}
+
 interface MonitorServiceType {
     val monitorAssistanceType: MonitorAssistanceType
 }

src/main/kotlin/ufrpe/sbpc/botpcd/repository/AttendanceRepository.kt

@@ -5,15 +5,16 @@ import org.springframework.data.jpa.repository.Modifying
 import org.springframework.data.jpa.repository.Query
 import org.springframework.data.repository.query.Param
 import ufrpe.sbpc.botpcd.entity.Attendance
-import ufrpe.sbpc.botpcd.entity.ServiceType
 import ufrpe.sbpc.botpcd.entity.Attendant
 import ufrpe.sbpc.botpcd.entity.PWD
+import ufrpe.sbpc.botpcd.entity.ServiceType
 import java.time.LocalDateTime
 
 interface AttendanceRepository : JpaRepository<Attendance, Long> {
 	@Query("SELECT COUNT(att) FROM Attendance att WHERE att.serviceType = :serviceType AND att.startDateTime IS NULL")
 	fun countRequestAttendanceOfService(serviceType: ServiceType): Long
-
+	@Query("SELECT att FROM Attendance att WHERE att.startDateTime IS NULL AND att.attendantType = 'COMMITTEE_MEMBER'")
+	fun findPendingCommitteeMemberAttendances(): List<Attendance>
   @Query("SELECT att from Attendance att where att.serviceType = :serviceType AND att.startDateTime is null order by att.requestDateTime asc")
   fun findRequestAttendanceOfService(serviceType: ServiceType) : Attendance?
 
@@ -37,4 +38,8 @@ interface AttendanceRepository : JpaRepository<Attendance, Long> {
 	@Modifying(flushAutomatically = true, clearAutomatically = true) // Modificação aqui
 	@Query("DELETE FROM Attendance a WHERE a.pwd = :pwd")
 	fun deleteAllByPwd(@Param("pwd") pwd: PWD)
+
+	@Modifying(flushAutomatically = true, clearAutomatically = true) // Modificação aqui
+	@Query("DELETE FROM Attendance a WHERE a.attendant = :att")
+	fun deleteAllByAttendant(@Param("att") att: Attendant)
 }

src/main/kotlin/ufrpe/sbpc/botpcd/repository/AttendantRepository.kt

@@ -5,4 +5,5 @@ import ufrpe.sbpc.botpcd.entity.Attendant
 
 interface AttendantRepository: JpaRepository<Attendant, Long> {
     fun findByPhoneNumber(phone: String): Attendant?
+    fun findByName(name: String): Attendant?
 }

src/main/kotlin/ufrpe/sbpc/botpcd/repository/MonitorRepository.kt

@@ -8,6 +8,7 @@ import ufrpe.sbpc.botpcd.entity.UserStatus
 
 interface MonitorRepository : JpaRepository<Monitor, Long>{
     fun findByPhoneNumber(phoneNumber: String): Monitor?
+    fun findByName(phoneName: String): Monitor?
     fun findByStatus(status: UserStatus): List<Monitor>
     @Query("SELECT m from Monitor m where m.status = :status and m.assistanceType = :assistanceType")
     fun findAvailableMonitor(status: UserStatus, assistanceType: MonitorAssistanceType): List<Monitor>

src/main/kotlin/ufrpe/sbpc/botpcd/service/AttendanceService.kt

@@ -3,6 +3,7 @@ package ufrpe.sbpc.botpcd.service
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
 import ufrpe.sbpc.botpcd.entity.*
 import ufrpe.sbpc.botpcd.entity.Attendance
 import ufrpe.sbpc.botpcd.entity.Attendant
@@ -17,7 +18,6 @@ import ufrpe.sbpc.botpcd.repository.AttendanceRepository
 import ufrpe.sbpc.botpcd.repository.CommitteeMemberRepository
 import ufrpe.sbpc.botpcd.repository.MessageExchangeRepository
 import ufrpe.sbpc.botpcd.repository.MonitorRepository
-import ufrpe.sbpc.botpcd.service.QueueService
 import ufrpe.sbpc.botpcd.util.createOptions
 import java.time.LocalDateTime
 
@@ -26,12 +26,188 @@ class AttendanceService(
 		private val queryService: QueueService,
     private val attendanceRepository: AttendanceRepository,
     private val whatsappService: WhatsappService,
-    private val attendantStatusService: AttendantStatusService,
     private val monitorRepository: MonitorRepository,
     private val committeeMemberRepository: CommitteeMemberRepository,
     private val messageExchangeRepository: MessageExchangeRepository,
 ) {
+    @Transactional
+    fun setMonitorStatus(monitor: Monitor, status: UserStatus) {
+        monitor.status = status
+        monitorRepository.save(monitor)
+    }
+
+    @Transactional
+    fun setCommitteeMemberStatus(member: CommitteeMember, status: UserStatus) {
+        member.status = status
+        committeeMemberRepository.save(member)
+    }
+
+    private fun updateAttendantStatus(botNumber: String, attendant: Attendant, newStatus: UserStatus) {
+        when (attendant) {
+            is Monitor -> {
+                setMonitorStatus(attendant, newStatus)
+                if(newStatus == UserStatus.AVAILABLE) {
+                    val serviceType = ServiceType.getServiceByMonitorAssistanceType(attendant.assistanceType)
+                    attendanceRepository.findRequestAttendanceOfService(serviceType)?.let{requestAttendance ->
+                        directToAvailableAttendant(botNumber, requestAttendance.pwd, serviceType)
+                    }
+                }
+            }
+            is CommitteeMember -> {
+                setCommitteeMemberStatus(attendant, newStatus)
+                if(newStatus == UserStatus.AVAILABLE) {
+                    attendanceRepository.findPendingCommitteeMemberAttendances().firstOrNull()?.let { attendance ->
+                        directToAvailableAttendant(botNumber, attendance.pwd, attendance.serviceType)
+                    }
+                }
+            }
+        }
+    }
+    fun createOptionsWithCancel(options: List<String>, header: String = "", author: String = ""): String {
+        var msg = createOptions(options, header, author)
+        return "${msg}- Escreva \"cancelar\" para sair do menu"
+    }
+    val changeStatusTextOptionsFor = mapOf(
+        "AVAILABLE" to createOptionsWithCancel(
+            listOf("Ficar Indisponível"),
+            "Você está *Disponível* no momento", "BotPCD"
+        ),
+        "UNAVAILABLE" to createOptionsWithCancel(
+            listOf("Ficar Disponível"),
+            "Você está *Indisponível* no momento", "BotPCD"
+        ),
+        "BUSY" to createOptionsWithCancel(
+            listOf(
+                "Encerrar atendimento e Ficar Disponível",
+                "Encerrar atendimento e Ficar Indisponível"
+            ),
+            "Você está *em atendimento*", "BotPCD"
+        )
+    )
+
+    fun sendStatusChanger(attendant: Attendant, botPhoneNumber: String) {
+        val userPhoneNumber = attendant.phoneNumber
+        val messageToSend = when (attendant.status) {
+            UserStatus.AVAILABLE -> changeStatusTextOptionsFor[UserStatus.AVAILABLE.toString()]
+            UserStatus.UNAVAILABLE -> changeStatusTextOptionsFor[UserStatus.UNAVAILABLE.toString()]
+            UserStatus.BUSY -> changeStatusTextOptionsFor[UserStatus.BUSY.toString()]
+        }
+        whatsappService.sendMessage(botPhoneNumber, userPhoneNumber, messageToSend ?: "")
+    }
+
+    @Transactional
+    fun processStatusChangeResponse(botNumber: String, attendant: Attendant, userResponse: String, botPhoneNumber: String) {
+        var confirmationMessage: String? = null
+        val userPhoneNumber = attendant.phoneNumber
+
+        when (attendant.status) {
+            UserStatus.AVAILABLE -> {
+                when (userResponse.lowercase()) {
+                    "1" -> {
+                        updateAttendantStatus(botNumber, attendant, UserStatus.UNAVAILABLE)
+                        confirmationMessage = "Seu status foi atualizado para Indisponível."
+                    }
+
+                    "cancelar" -> {
+                        confirmationMessage = "Você continua Disponível."
+                    }
+
+                    else -> {
+                        confirmationMessage = "Opção inválida. Seu status permanece Disponível."
+                    }
+                }
+            }
+
+            UserStatus.UNAVAILABLE -> {
+                when (userResponse.lowercase()) {
+                    "1" -> {
+                        updateAttendantStatus(botNumber, attendant, UserStatus.AVAILABLE)
+                        confirmationMessage = "Seu status foi atualizado para Disponível."
+                    }
+
+                    "cancelar" -> {
+                        confirmationMessage = "Você continua Indisponível."
+                    }
+
+                    else -> {
+                        confirmationMessage = "Opção inválida. Seu status permanece Indisponível."
+                    }
+                }
+            }
+
+            UserStatus.BUSY -> {
+                val attendance = attendanceRepository.findStartedAttendanceOfAttendant(attendant)
+                if (attendance != null) {
+                    when (userResponse.lowercase()) {
+                        "1" -> {
+                            updateAttendantStatus(botNumber, attendant, UserStatus.AVAILABLE)
+                            sendFinishedAttendanceMessage(botPhoneNumber, attendance)
+                            confirmationMessage = "Atendimento encerrado. Seu status foi atualizado para Disponível."
+                            finishAttendance(attendance)
+                        }
+                        "2" -> {
+                            updateAttendantStatus(botNumber, attendant, UserStatus.UNAVAILABLE)
+                            sendFinishedAttendanceMessage(botPhoneNumber, attendance)
+                            confirmationMessage = "Atendimento encerrado. Seu status foi atualizado para Indisponível."
+                            finishAttendance(attendance)
+                        }
+
+                        "cancelar" -> {
+                            confirmationMessage = "Você continua em atendimento."
+                        }
+
+                        else -> {
+                            confirmationMessage = "Opção inválida. Seu status permanece Ocupado."
+                        }
+                    }
+                } else {
+                    logger.warn("Atendente está ocupado  ${attendant.name} sem atendimento")
+                }
+            }
+        }
+
+        confirmationMessage?.let {
+            whatsappService.sendMessage(botPhoneNumber, userPhoneNumber, it, "BotPCD")
+        }
+    }
+
+    private fun sendFinishedAttendanceMessage(botPhoneNumber: String, attendance: Attendance) {
+        whatsappService.sendMessage(
+            botPhoneNumber,
+            attendance.pwd.phoneNumber,
+            "Atendimento encerrado",
+            "BotPCD"
+        )
+    }
+
+    fun findAvailableMonitors(): List<Monitor> {
+        return monitorRepository.findByStatus(UserStatus.AVAILABLE)
+    }
+
+    fun findAvailableCommitteeMembers(): List<CommitteeMember> {
+        return committeeMemberRepository.findByStatus(UserStatus.AVAILABLE)
+    }
+
+    fun findAvailableMonitorsByType(assistanceType: MonitorAssistanceType): List<Monitor> {
+        val availableMonitors = findAvailableMonitors()
+        return availableMonitors.filter { it.assistanceType == assistanceType }
+    }
+    fun finishAttendance(attendance: Attendance) {
+        attendance.apply {
+            endDateTime = LocalDateTime.now()
+        }
+        attendanceRepository.save(attendance)
+    }
+    val awaitServiceMessage = "No momento não há atendentes disponíveis. Por favor, aguarde na fila de espera e retornaremos assim que possível."
+    fun sendWaitListMessage(botNumber: String, pwd: PWD) {
+        whatsappService.sendMessage(
+            botNumber,
+            pwd.phoneNumber,
+            awaitServiceMessage
+        )
+    }
     val logger: Logger = LoggerFactory.getLogger(AttendanceService::class.java)
+
     fun sendServices(botNumber: String, pwd: PWD) {
         whatsappService.sendMessage(botNumber, pwd.phoneNumber, createSendServicesMessage(pwd.disabilities.first(), pwd))
     }
@@ -49,10 +225,10 @@ class AttendanceService(
     fun makeAttendantBusy(attendant: Attendant) {
         when (attendant) {
             is Monitor -> {
-                attendantStatusService.setMonitorStatus(attendant, UserStatus.BUSY)
+                setMonitorStatus(attendant, UserStatus.BUSY)
             }
             is CommitteeMember -> {
-                attendantStatusService.setCommitteeMemberStatus(attendant, UserStatus.BUSY)
+                setCommitteeMemberStatus(attendant, UserStatus.BUSY)
             }
         }
     }
@@ -168,12 +344,4 @@ $message
             """.trimIndent()
     )
 }
-
-fun sendWaitListMessage(botNumber: String, pwd: PWD) {
-    whatsappService.sendMessage(
-        botNumber,
-        pwd.phoneNumber,
-        "No momento não há atendentes disponíveis. Por favor, aguarde na fila de espera e retornaremos assim que possível."
-    )
-}
 }

src/main/kotlin/ufrpe/sbpc/botpcd/service/AttendantFlowService.kt

@@ -7,16 +7,15 @@ import ufrpe.sbpc.botpcd.repository.AttendanceRepository
 
 @Service
 class AttendantFlowService(
-    private val attendantStatusService: AttendantStatusService,
     private val attendanceRepository: AttendanceRepository,
     private val attendanceService: AttendanceService
 ) {
     val botPcdRegex = Regex("^\\s*bot\\s*pcd\\s*$", RegexOption.IGNORE_CASE)
     fun redirect(botNumber: String, lastBotMessageText: String?, attendant: Attendant, message: String) {
         if (botPcdRegex.matches(message)) {
-            attendantStatusService.sendStatusChanger(attendant, botNumber)
-        } else if (lastBotMessageText in attendantStatusService.changeStatusTextOptionsFor.values) {
-            attendantStatusService.processStatusChangeResponse(attendant, message, botNumber)
+            attendanceService.sendStatusChanger(attendant, botNumber)
+        } else if (lastBotMessageText in attendanceService.changeStatusTextOptionsFor.values) {
+            attendanceService.processStatusChangeResponse(botNumber, attendant, message, botNumber)
         } else {
             attendanceRepository.findStartedAttendanceOfAttendant(attendant)?.let { attendance ->
                 attendanceService.redirectMessageToPwd(botNumber, message, attendance.pwd, attendant)