78 lines
3.3 KiB
Kotlin
78 lines
3.3 KiB
Kotlin
package moe.kageru.kagebot.features
|
|
|
|
import arrow.core.Either
|
|
import arrow.core.Tuple3
|
|
import arrow.core.extensions.either.monad.flatMap
|
|
import arrow.core.extensions.list.monad.map
|
|
import arrow.core.extensions.listk.functorFilter.filter
|
|
import arrow.core.toOption
|
|
import arrow.syntax.collections.destructured
|
|
import com.fasterxml.jackson.annotation.JsonProperty
|
|
import moe.kageru.kagebot.Log
|
|
import moe.kageru.kagebot.MessageUtil.sendEmbed
|
|
import moe.kageru.kagebot.Util.findRole
|
|
import moe.kageru.kagebot.Util.findUser
|
|
import moe.kageru.kagebot.config.Config
|
|
import moe.kageru.kagebot.config.LocalizationSpec
|
|
import moe.kageru.kagebot.extensions.*
|
|
import moe.kageru.kagebot.persistence.Dao
|
|
import org.javacord.api.entity.permission.Role
|
|
import org.javacord.api.entity.user.User
|
|
import org.javacord.api.event.message.MessageCreateEvent
|
|
import java.time.Duration
|
|
import java.time.Instant
|
|
|
|
class TimeoutFeature(@JsonProperty("role") role: String) : MessageFeature {
|
|
private val timeoutRole: Role = findRole(role).unwrap()
|
|
|
|
override fun handle(message: MessageCreateEvent) {
|
|
message.readableMessageContent.split(' ', limit = 4).let { args ->
|
|
Either.cond(
|
|
args.size >= 3,
|
|
{ Tuple3(args[1], args[2], args.getOrNull(3)) },
|
|
{ "Error: expected “<command> <user> <time> [<reason>]”. If the name contains spaces, please use the user ID instead." }
|
|
).flatMap {
|
|
it.mapFirst(::findUser).toEither { "Error: User ${it.a} not found, consider using the user ID" }
|
|
}.flatMap {
|
|
it.mapSecond { time -> time.toLongOrNull().toOption() }.toEither { "Error: malformed time “${it.b}”" }
|
|
}.on { (user, time, _) ->
|
|
applyTimeout(user, time)
|
|
}.fold(
|
|
{ message.channel.sendMessage(it) },
|
|
{ (user, time, reason) ->
|
|
user.sendEmbed {
|
|
addField("Timeout", Config.localization[LocalizationSpec.timeout].replace("@@", "$time"))
|
|
reason?.let { addField("Reason", it) }
|
|
}
|
|
}
|
|
)
|
|
}
|
|
}
|
|
|
|
private fun applyTimeout(user: User, time: Long) {
|
|
val oldRoles = user.roles()
|
|
.filter { !it.isManaged }
|
|
.onEach { user.removeRole(it) }
|
|
.map { it.id }
|
|
user.addRole(timeoutRole)
|
|
val releaseTime = Instant.now().plus(Duration.ofMinutes(time)).epochSecond
|
|
Dao.saveTimeout(releaseTime, user.id, oldRoles)
|
|
Log.info("Removed roles ${oldRoles.joinToString()} from user ${user.discriminatedName}")
|
|
}
|
|
|
|
fun checkAndRelease(): Unit = Dao.getAllTimeouts()
|
|
.filter { releaseTime -> Instant.now().epochSecond > releaseTime }
|
|
.map { Dao.deleteTimeout(it) }
|
|
.map { it.destructured() }
|
|
.forEach { (userId, roleIds) ->
|
|
Config.server.memberById(userId).fold(
|
|
{ Log.warn("Tried to free user $userId, but couldn’t find them on the server anymore") },
|
|
{ user ->
|
|
roleIds.forEach { findRole("$it").map(user::addRole) }
|
|
user.removeRole(timeoutRole)
|
|
Log.info("Lifted timeout from user ${user.discriminatedName}. Stored roles ${roleIds.joinToString()}")
|
|
}
|
|
)
|
|
}
|
|
}
|