GH-1428 Add punishment system

buildSrc/src/main/kotlin/Versions.kt

@@ -14,6 +14,7 @@ object Versions {
     const val ADVENTURE_TEXT_MINIMESSAGE = "4.26.1"
     const val OKAERI_CONFIGS = "6.0.0-beta.27"
 
+    const val JOOQ = "3.21.8"
     const val MARIA_DB = "3.5.9"
     const val POSTGRESQL = "42.7.13"
     const val H2 = "2.4.240"
@@ -26,8 +27,6 @@ object Versions {
     const val GUAVA = "33.6.0-jre"
     const val GSON = "2.14.0"
 
-    const val EXPRESSIBLE = "1.3.6"
-    const val PANDA_UTILITIES = "0.5.3-alpha"
     const val APACHE_COMMONS = "2.22.0"
 
     const val TRIUMPH_GUI = "3.1.13"

buildSrc/src/main/kotlin/eternalcode-java.gradle.kts

@@ -6,11 +6,11 @@ group = "com.eternalcode"
 version = "2.0.1-SNAPSHOT"
 
 java {
-    toolchain.languageVersion.set(JavaLanguageVersion.of(21))
+    toolchain.languageVersion.set(JavaLanguageVersion.of(25))
 }
 
 tasks.compileJava {
     options.compilerArgs = listOf("-Xlint:deprecation", "-parameters")
     options.encoding = "UTF-8"
-    options.release = 21
+    options.release = 25
 }

docker-compose.yml

@@ -0,0 +1,15 @@
+services:
+  postgres:
+    image: postgres:16
+    container_name: eternalcore-postgres
+    environment:
+      POSTGRES_DB: eternalcore
+      POSTGRES_USER: eternalcore
+      POSTGRES_PASSWORD: eternalcore
+    ports:
+      - "5432:5432"
+    volumes:
+      - eternalcore-postgres-data:/var/lib/postgresql/data
+
+volumes:
+  eternalcore-postgres-data:

eternalcore-api-example/build.gradle.kts

@@ -40,7 +40,7 @@ bukkit {
 }
 
 java {
-    toolchain.languageVersion.set(JavaLanguageVersion.of(21))
+    toolchain.languageVersion.set(JavaLanguageVersion.of(25))
 }
 
 tasks.withType<JavaCompile> {

eternalcore-api/src/main/java/com/eternalcode/core/feature/punishment/Punishment.java

@@ -0,0 +1,149 @@
+package com.eternalcode.core.feature.punishment;
+
+import java.time.Instant;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.UUID;
+
+/**
+ * Immutable punishmentapi record. Active state is derived, never stored:
+ * a punishment is active when it is not revoked and not expired.
+ * KICK is instantaneous and has no meaningful active state.
+ *
+ * @param expiresAt null = permanent
+ * @param revokedAt null = not revoked
+ */
+public record Punishment(
+    UUID id,
+    PunishmentTarget target,
+    PunishmentTarget operator,
+    PunishmentType type,
+    String reason,
+    Instant createdAt,
+    Instant expiresAt,
+    Instant revokedAt
+) {
+
+    public Punishment {
+        if (expiresAt != null && expiresAt.isBefore(createdAt)) {
+            throw new IllegalArgumentException("expiresAt cannot be before createdAt");
+        }
+        if (revokedAt != null && revokedAt.isBefore(createdAt)) {
+            throw new IllegalArgumentException("revokedAt cannot be before createdAt");
+        }
+    }
+
+    public Optional<Instant> expiresAtOptional() {
+        return Optional.ofNullable(this.expiresAt);
+    }
+
+    public Optional<Instant> revokedAtOptional() {
+        return Optional.ofNullable(this.revokedAt);
+    }
+
+    public boolean isPermanent() {
+        return this.expiresAt == null;
+    }
+
+    public boolean isRevoked() {
+        return this.revokedAt != null;
+    }
+
+    public boolean isExpired(Instant now) {
+        return this.expiresAt != null && !now.isBefore(this.expiresAt);
+    }
+
+    public boolean isActive(Instant now) {
+        return !this.isRevoked() && !this.isExpired(now);
+    }
+
+    public boolean isActive() {
+        return this.isActive(Instant.now());
+    }
+
+    public Punishment revoke(Instant revokedAt) {
+        if (this.isRevoked()) {
+            throw new IllegalStateException("Punishment " + this.id + " is already revoked");
+        }
+
+        return new Punishment(
+            this.id,
+            this.target,
+            this.operator,
+            this.type,
+            this.reason,
+            this.createdAt,
+            this.expiresAt,
+            revokedAt
+        );
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    public static final class Builder {
+
+        private UUID id = UUID.randomUUID();
+        private PunishmentTarget target;
+        private PunishmentTarget operator;
+        private PunishmentType type;
+        private String reason;
+        private Instant createdAt = Instant.now();
+        private Instant expiresAt;
+        private Instant revokedAt;
+
+        public Builder id(UUID id) {
+            this.id = id;
+            return this;
+        }
+
+        public Builder target(PunishmentTarget target) {
+            this.target = target;
+            return this;
+        }
+
+        public Builder operator(PunishmentTarget operator) {
+            this.operator = operator;
+            return this;
+        }
+
+        public Builder type(PunishmentType type) {
+            this.type = type;
+            return this;
+        }
+
+        public Builder reason(String reason) {
+            this.reason = reason;
+            return this;
+        }
+
+        public Builder createdAt(Instant createdAt) {
+            this.createdAt = createdAt;
+            return this;
+        }
+
+        public Builder expiresAt(Instant expiresAt) {
+            this.expiresAt = expiresAt;
+            return this;
+        }
+
+        public Builder revokedAt(Instant revokedAt) {
+            this.revokedAt = revokedAt;
+            return this;
+        }
+
+        public Punishment build() {
+            return new Punishment(
+                this.id,
+                this.target,
+                this.operator,
+                this.type,
+                this.reason,
+                this.createdAt,
+                this.expiresAt,
+                this.revokedAt
+            );
+        }
+    }
+}

eternalcore-api/src/main/java/com/eternalcode/core/feature/punishment/PunishmentService.java

@@ -0,0 +1,34 @@
+package com.eternalcode.core.feature.punishment;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+import net.kyori.adventure.text.Component;
+
+public interface PunishmentService {
+
+    Punishment ban(PunishmentTarget target, PunishmentTarget operator, String reason, Instant expiresAt, List<Component> kickMessage);
+    void unban(PunishmentTarget target, PunishmentTarget operator);
+
+    Punishment mute(PunishmentTarget target, PunishmentTarget operator, String reason, Instant expiresAt);
+    void unmute(PunishmentTarget target, PunishmentTarget operator);
+
+    Punishment warn(PunishmentTarget target, PunishmentTarget operator, String reason, Instant expiresAt);
+
+    void kick(PunishmentTarget target, PunishmentTarget operator, String reason, List<Component> kickMessage, boolean massKick);
+
+    boolean isBanned(UUID targetUuid);
+
+    boolean isMuted(UUID targetUuid);
+
+    Optional<Punishment> getActiveBan(UUID targetUuid);
+
+    Optional<Punishment> getActiveMute(UUID targetUuid);
+
+    List<Punishment> findActive(UUID targetUuid);
+
+    List<Punishment> activeBans();
+    List<Punishment> activeMutes();
+    List<Punishment> activeWarns();
+}

eternalcore-api/src/main/java/com/eternalcode/core/feature/punishment/PunishmentTarget.java

@@ -0,0 +1,41 @@
+package com.eternalcode.core.feature.punishment;
+
+import java.util.UUID;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public record PunishmentTarget(UUID uuid, String name) {
+
+    public static final UUID CONSOLE_UUID = UUID.nameUUIDFromBytes("CONSOLE_UUID".getBytes());
+
+    public static PunishmentTarget of(OfflinePlayer player) {
+        return new PunishmentTarget(player.getUniqueId(), player.getName());
+    }
+
+    public static PunishmentTarget of(Player player) {
+        return new PunishmentTarget(player.getUniqueId(), player.getName());
+    }
+
+    public static PunishmentTarget of(CommandSender sender) {
+        if (sender instanceof Player player) {
+            return of(player);
+        }
+
+        return new PunishmentTarget(CONSOLE_UUID, sender.getName());
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+
+        return obj instanceof PunishmentTarget other && this.uuid.equals(other.uuid);
+    }
+
+    @Override
+    public int hashCode() {
+        return this.uuid.hashCode();
+    }
+}

eternalcore-api/src/main/java/com/eternalcode/core/feature/punishment/PunishmentType.java

@@ -0,0 +1,10 @@
+package com.eternalcode.core.feature.punishment;
+
+public enum PunishmentType {
+
+    BAN,
+    KICK,
+    MUTE,
+    WARN
+
+}

eternalcore-api/src/main/java/com/eternalcode/core/feature/punishment/history/PunishmentHistoryEntry.java

@@ -0,0 +1,29 @@
+package com.eternalcode.core.feature.punishment.history;
+
+import com.eternalcode.core.feature.punishment.PunishmentTarget;
+import java.time.Instant;
+import java.util.Optional;
+import java.util.UUID;
+
+public record PunishmentHistoryEntry(
+    UUID id,
+    UUID punishmentId,
+    PunishmentTarget target,
+    PunishmentTarget operator,
+    HistoryAction action,
+    String reason,
+    Instant timestamp,
+    Instant expiresAt
+) {
+    public Optional<Instant> expiresAtOptional() {
+        return Optional.ofNullable(this.expiresAt);
+    }
+
+    public boolean isPermanent() {
+        return this.expiresAt == null;
+    }
+
+    public enum HistoryAction {
+        BAN, UNBAN, KICK, KICK_ALL, MUTE, UNMUTE, WARN, EXPIRE, BAN_IP, UNBAN_IP
+    }
+}

eternalcore-api/src/main/java/com/eternalcode/core/feature/punishment/history/PunishmentHistoryService.java

@@ -0,0 +1,13 @@
+package com.eternalcode.core.feature.punishment.history;
+
+import java.util.List;
+import java.util.UUID;
+
+public interface PunishmentHistoryService {
+
+    void record(PunishmentHistoryEntry entry);
+
+    List<PunishmentHistoryEntry> findByTarget(UUID targetUuid, int page, int pageSize);
+
+    List<PunishmentHistoryEntry> findRecent(int page, int pageSize);
+}