Update to 26.2

api/build.gradle.kts

@@ -3,12 +3,19 @@ plugins {
 }
 
 dependencies {
+    implementation(project(":web-api")) // Web-API
+    compileOnly("org.projectlombok:lombok:1.18.46")
+    annotationProcessor("org.projectlombok:lombok:1.18.46")
     // Cosmos
     compileOnly("com.alttd.cosmos:cosmos-api:1.21.8-R0.1-SNAPSHOT") {
         isChanging = true
     }
     compileOnly("org.spongepowered:configurate-yaml:4.2.0") // Configurate
     compileOnly("net.luckperms:api:5.5") // Luckperms
+
+    //API validation
+    implementation("org.hibernate.validator:hibernate-validator:9.0.1.Final")
+    implementation("org.glassfish:jakarta.el:5.0.0-M1")
 }
 
 publishing {

api/src/main/java/com/alttd/chat/config/Config.java

@@ -183,11 +183,15 @@ public final class Config {
     private static void settings() {
         PREFIXGROUPS = getList("settings.prefix-groups",
                 Lists.newArrayList("discord", "socialmedia", "eventteam", "eventleader", "youtube", "twitch",
-                        "developer"));
+                        "developer"
+                )
+        );
         CONFLICTINGPREFIXGROUPS = getList("settings.prefix-conflicts-groups",
-                Lists.newArrayList("eventteam", "eventleader"));
+                Lists.newArrayList("eventteam", "eventleader")
+        );
         STAFFGROUPS = getList("settings.staff-groups",
-                Lists.newArrayList("trainee", "moderator", "headmod", "admin", "manager", "owner"));
+                Lists.newArrayList("trainee", "moderator", "headmod", "admin", "manager", "owner")
+        );
         CONSOLENAME = getString("settings.console-name", CONSOLENAME);
         CONSOLEUUID = UUID.fromString(getString("settings.console-uuid", CONSOLEUUID.toString()));
         MINIMIUMSTAFFRANK = getString("settings.minimum-staff-rank", MINIMIUMSTAFFRANK);
@@ -413,7 +417,8 @@ public final class Config {
         ConfigurationNode node = getNode("chat-channels");
         if (node.empty()) {
             getString("chat-channels.ac.format",
-                    "<white><gray><sender></gray> <hover:show_text:on <server>><yellow>to <channel></yellow></hover><gray>: <message>");
+                    "<white><gray><sender></gray> <hover:show_text:on <server>><yellow>to <channel></yellow></hover><gray>: <message>"
+            );
             getList("chat-channels.ac.servers", List.of("lobby"));
             getBoolean("chat-channels.ac.proxy", false);
             node = getNode("chat-channels");
@@ -617,11 +622,15 @@ public final class Config {
         NICK_WAIT_TIME = getLong("nicknames.wait-time", NICK_WAIT_TIME);
         NICK_ITEM_LORE = getList("nicknames.item-lore",
                 List.of("<aqua>New nick: <newnick>", "<aqua>Old nick: <oldnick>", "<aqua>Last changed: <lastchanged>",
-                        "<green>Left click to Accept <light_purple>| <red>Right click to Deny"));
+                        "<green>Left click to Accept <light_purple>| <red>Right click to Deny"
+                )
+        );
         NICK_BLOCKED_COLOR_CODESLIST = getList("nicknames.blocked-color-codes", List.of("&k", "&l", "&n", "&m", "&o"));
         NICK_ALLOWED_COLOR_CODESLIST = getList("nicknames.allowed-color-codes",
                 List.of("&0", "&1", "&2", "&3", "&4", "&5", "&6", "&7", "&8", "&9", "&a", "&b", "&c", "&d", "&e", "&f",
-                        "&r"));
+                        "&r"
+                )
+        );
         NICK_CURRENT = getString("nicknames.messages.nick-current", NICK_CURRENT);
     }
 
@@ -641,4 +650,10 @@ public final class Config {
         CHAT_LOG_DELETE_OLDER_THAN_DAYS = getLong("chat-log.delete-older-than-days", CHAT_LOG_DELETE_OLDER_THAN_DAYS);
         CHAT_LOG_SAVE_DELAY_MINUTES = getLong("chat-log.save-delay-minutes", CHAT_LOG_SAVE_DELAY_MINUTES);
     }
+
+    public static String CHAT_WEB_SERVER_BASE_URL = "http://10.0.0.121:8080";
+
+    private static void webServerSettings() {
+        CHAT_WEB_SERVER_BASE_URL = getString("web-server.base-url", CHAT_WEB_SERVER_BASE_URL);
+    }
 }

api/src/main/java/com/alttd/chat/database/ChatLogQueries.java

@@ -15,15 +15,25 @@ import java.util.concurrent.CompletionException;
 public class ChatLogQueries {
 
     protected static void createChatLogTable() {
-        String nicknamesTableQuery = "CREATE TABLE IF NOT EXISTS chat_log("
+        String nicknamesTableQuery = """
-                + "uuid CHAR(48) NOT NULL,"
+                CREATE TABLE IF NOT EXISTS chat_log (
-                + "time_stamp TIMESTAMP(6) NOT NULL, "
+                    id BIGINT AUTO_INCREMENT PRIMARY KEY,
-                + "server VARCHAR(50) NOT NULL, "
+                    uuid CHAR(36) NOT NULL,
-                + "chat_message VARCHAR(300) NOT NULL, "
+                    time_stamp TIMESTAMP(6) NOT NULL,
-                + "blocked BIT(1) NOT NULL DEFAULT 0"
+                    server VARCHAR(50) NOT NULL,
-                + ")";
+                    type VARCHAR(16) NOT NULL DEFAULT 'public',
+                    channel VARCHAR(36) DEFAULT NULL,
+                    receiver CHAR(36) DEFAULT NULL,
+                    chat_message VARCHAR(300) NOT NULL,
+                    mini_message JSON,
+                    blocked BOOLEAN NOT NULL DEFAULT FALSE,
                 
-        try (PreparedStatement preparedStatement = DatabaseConnection.getConnection().prepareStatement(nicknamesTableQuery)) {
+                    INDEX idx_time_stamp (time_stamp)
+                )
+                """;
+
+        try (PreparedStatement preparedStatement = DatabaseConnection.getConnection().prepareStatement(
+                nicknamesTableQuery)) {
             preparedStatement.executeUpdate();
         } catch (Throwable throwable) {
             ALogger.error("Failed to create chat log table", throwable);
@@ -31,7 +41,7 @@ public class ChatLogQueries {
     }
 
     public static @NotNull CompletableFuture<Boolean> storeMessages(HashMap<UUID, List<ChatLog>> chatMessages) {
-        String insertQuery = "INSERT INTO chat_log (uuid, time_stamp, server, chat_message, blocked) VALUES (?, ?, ?, ?, ?)";
+        String insertQuery = "INSERT INTO chat_log (uuid, time_stamp, server, type, channel, receiver, chat_message, mini_message, blocked) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)";
         return CompletableFuture.supplyAsync(() -> {
             try (Connection connection = DatabaseConnection.createTransactionConnection()) {
                 PreparedStatement preparedStatement = connection.prepareStatement(insertQuery);
@@ -60,7 +70,7 @@ public class ChatLogQueries {
     }
 
     public static @NotNull CompletableFuture<List<ChatLog>> retrieveMessages(ChatLogHandler chatLogHandler, UUID uuid, Duration duration, String server) {
-        String query = "SELECT * FROM chat_log WHERE uuid = ? AND time_stamp > ? AND server = ?";
+        String query = "SELECT * FROM chat_log WHERE uuid = ? AND time_stamp > ? AND server = ? AND type = 'public'";
         return CompletableFuture.supplyAsync(() -> {
             try (Connection connection = DatabaseConnection.getConnection()) {
                 PreparedStatement preparedStatement = connection.prepareStatement(query);
@@ -70,13 +80,14 @@ public class ChatLogQueries {
                 ResultSet resultSet = preparedStatement.executeQuery();
                 List<ChatLog> chatLogs = new ArrayList<>();
                 while (resultSet.next()) {
-                    ChatLog chatLog = chatLogHandler.loadFromResultSet(resultSet);
+                    chatLogHandler.loadFromResultSet(resultSet).ifPresent(chatLogs::add);
-                    chatLogs.add(chatLog);
                 }
                 return chatLogs;
             } catch (SQLException sqlException) {
                 ALogger.error(String.format("Failed to retrieve messages for user %s", uuid), sqlException);
-                throw new CompletionException(String.format("Failed to retrieve messages for user %s", uuid), sqlException);
+                throw new CompletionException(String.format("Failed to retrieve messages for user %s", uuid),
+                        sqlException
+                );
             }
         });
     }
@@ -90,8 +101,13 @@ public class ChatLogQueries {
                 preparedStatement.setTimestamp(1, Timestamp.from(Instant.now().minus(duration)));
                 return preparedStatement.execute();
             } catch (SQLException sqlException) {
-                ALogger.error(String.format("Failed to delete messages older than %s days", duration.toDays()), sqlException);
+                ALogger.error(String.format("Failed to delete messages older than %s days", duration.toDays()),
-                throw new CompletionException(String.format("Failed to delete messages older than %s days", duration.toDays()), sqlException);
+                        sqlException
+                );
+                throw new CompletionException(String.format("Failed to delete messages older than %s days",
+                        duration.toDays()
+                ), sqlException
+                );
             }
         });
     }

api/src/main/java/com/alttd/chat/database/DatabaseConnection.java

@@ -1,6 +1,5 @@
 package com.alttd.chat.database;
 
-
 import com.alttd.chat.config.Config;
 
 import java.sql.Connection;
@@ -27,6 +26,7 @@ public class DatabaseConnection {
 
     /**
      * Opens the connection if it's not already open.
+     *
      * @throws SQLException If it can't create the connection.
      */
     public void openConnection() throws SQLException {
@@ -45,14 +45,16 @@ public class DatabaseConnection {
             }
 
             connection = DriverManager.getConnection(
-                    "jdbc:mysql://" + Config.IP + ":" + Config.PORT + "/" + Config.DATABASE + "?autoReconnect=true"+
+                    "jdbc:mysql://" + Config.IP + ":" + Config.PORT + "/" + Config.DATABASE + "?autoReconnect=true" +
-                    "&useSSL=false",
+                    "&useSSL=false&preserveInstants=true",
-                    Config.USERNAME, Config.PASSWORD);
+                    Config.USERNAME, Config.PASSWORD
+            );
         }
     }
 
     /**
      * Returns the connection for the database
+     *
      * @return Returns the connection.
      */
     public static Connection getConnection() {
@@ -69,13 +71,15 @@ public class DatabaseConnection {
      * Creates a transactional database connection.
      *
      * @return A {@code Connection} object representing the transactional database connection.
+     *
      * @throws SQLException If there is an error creating the database connection.
      */
     public static Connection createTransactionConnection() throws SQLException {
         connection = DriverManager.getConnection(
-                "jdbc:mysql://" + Config.IP + ":" + Config.PORT + "/" + Config.DATABASE + "?autoReconnect=true"+
+                "jdbc:mysql://" + Config.IP + ":" + Config.PORT + "/" + Config.DATABASE + "?autoReconnect=true" +
-                        "&useSSL=false",
+                "&useSSL=false&preserveInstants=true",
-                Config.USERNAME, Config.PASSWORD);
+                Config.USERNAME, Config.PASSWORD
+        );
         connection.setAutoCommit(false);
         return connection;
     }

api/src/main/java/com/alttd/chat/objects/Toggleable.java

@@ -18,9 +18,10 @@ public abstract class Toggleable {
 
     public static Toggleable getToggleable(UUID uuid) {
         for (Toggleable toggleableClass : togglableClasses) {
-            if (toggleableClass.isToggled(uuid))
+            if (toggleableClass.isToggled(uuid)) {
                 return toggleableClass;
             }
+        }
         return null;
     }
 

api/src/main/java/com/alttd/chat/objects/chat_log/ChatLog.java

@@ -1,6 +1,10 @@
 package com.alttd.chat.objects.chat_log;
 
 import com.alttd.chat.objects.BatchInsertable;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
 import org.jetbrains.annotations.NotNull;
 
 import java.sql.PreparedStatement;
@@ -9,44 +13,32 @@ import java.sql.Timestamp;
 import java.time.Instant;
 import java.util.UUID;
 
+@AllArgsConstructor
+@Getter
 public class ChatLog implements BatchInsertable {
 
     private final UUID uuid;
     private final Instant timestamp;
     private final String server;
+    private final ChatLogType type;
+    private final String channel;
+    private final String receiver;
     private final String message;
+    private final Component miniMessage;
     private final boolean blocked;
 
-    protected ChatLog(UUID uuid, Instant timestamp, String server, String message, boolean blocked) {
-        this.uuid = uuid;
-        this.timestamp = timestamp;
-        this.server = server;
-        this.message = message;
-        this.blocked = blocked;
-    }
-
     @Override
     public void prepareStatement(@NotNull PreparedStatement preparedStatement) throws SQLException {
         preparedStatement.setString(1, uuid.toString());
         preparedStatement.setTimestamp(2, Timestamp.from(timestamp));
         preparedStatement.setString(3, server);
-        preparedStatement.setString(4, message);
+        preparedStatement.setString(4, ChatLogTypeMapper.toDb(type));
-        preparedStatement.setInt(5, blocked ? 1 : 0);
+        preparedStatement.setString(5, channel);
-    }
+        preparedStatement.setString(6, receiver);
-
+        preparedStatement.setString(7, message);
-    public UUID getUuid() {
+        preparedStatement.setString(8,
-        return uuid;
+                miniMessage == null ? null : GsonComponentSerializer.gson().serialize(miniMessage)
-    }
+        );
-
+        preparedStatement.setInt(9, blocked ? 1 : 0);
-    public Instant getTimestamp() {
-        return timestamp;
-    }
-
-    public String getMessage() {
-        return message;
-    }
-
-    public boolean isBlocked() {
-        return blocked;
     }
 }

api/src/main/java/com/alttd/chat/objects/chat_log/ChatLogHandler.java

@@ -3,6 +3,9 @@ package com.alttd.chat.objects.chat_log;
 import com.alttd.chat.config.Config;
 import com.alttd.chat.database.ChatLogQueries;
 import com.alttd.chat.util.ALogger;
+import lombok.extern.slf4j.Slf4j;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
 import org.jetbrains.annotations.NotNull;
 
 import java.sql.ResultSet;
@@ -12,14 +15,17 @@ import java.time.Instant;
 import java.util.*;
 import java.util.concurrent.*;
 
+@Slf4j
 public class ChatLogHandler {
 
+    private final ChatLogWebHandler chatLogWebHandler = new ChatLogWebHandler();
     private static ChatLogHandler instance = null;
     private ScheduledExecutorService executorService = null;
 
     public static ChatLogHandler getInstance(boolean enableLogging) {
-        if (instance == null)
+        if (instance == null) {
             instance = new ChatLogHandler(enableLogging);
+        }
         return instance;
     }
 
@@ -35,23 +41,30 @@ public class ChatLogHandler {
         Duration deleteThreshold = Duration.ofDays(Config.CHAT_LOG_DELETE_OLDER_THAN_DAYS);
         ChatLogQueries.deleteOldMessages(deleteThreshold).thenAccept(success -> {
             if (success) {
-                ALogger.info(String.format("Deleted all messages older than %s days from chat log database.", deleteThreshold.toDays()));
+                ALogger.info(String.format("Deleted all messages older than %s days from chat log database.",
+                        deleteThreshold.toDays()
+                ));
             } else {
-                ALogger.warn(String.format("Failed to delete all messages older than %s days from chat log database.", deleteThreshold.toDays()));
+                ALogger.warn(String.format("Failed to delete all messages older than %s days from chat log database.",
+                        deleteThreshold.toDays()
+                ));
             }
         });
         executorService = Executors.newSingleThreadScheduledExecutor();
         executorService.scheduleAtFixedRate(() -> {
                     saveToDatabase(false);
-                    ALogger.info(String.format("Running scheduler to save messages with a %d delay", Config.CHAT_LOG_SAVE_DELAY_MINUTES));
+                    ALogger.info(String.format("Running scheduler to save messages with a %d delay",
+                            Config.CHAT_LOG_SAVE_DELAY_MINUTES
+                    ));
                 },
-                Config.CHAT_LOG_SAVE_DELAY_MINUTES, Config.CHAT_LOG_SAVE_DELAY_MINUTES, TimeUnit.MINUTES);
+                Config.CHAT_LOG_SAVE_DELAY_MINUTES, Config.CHAT_LOG_SAVE_DELAY_MINUTES, TimeUnit.MINUTES
+        );
         ALogger.info("Logging has started!");
     }
 
     /**
-     * Shuts down the executor service and saves the chat logs to the database.
+     * Shuts down the executor service and saves the chat logs to the database. Will throw an error if called on a
-     * Will throw an error if called on a ChatLogHandler that was started without logging
+     * ChatLogHandler that was started without logging
      */
     public void shutDown() {
         executorService.shutdown();
@@ -66,7 +79,7 @@ public class ChatLogHandler {
         return isSaving;
     }
 
-    public synchronized void addLog(ChatLog chatLog) {
+    private synchronized void addLog(ChatLog chatLog) {
         if (isBlocked()) {
             chatLogQueue.add(chatLog);
         } else {
@@ -100,17 +113,50 @@ public class ChatLogHandler {
         });
     }
 
-    public ChatLog loadFromResultSet(@NotNull ResultSet resultSet) throws SQLException {
+    public Optional<ChatLog> loadFromResultSet(@NotNull ResultSet resultSet) throws SQLException {
         UUID chatLogUUID = UUID.fromString(resultSet.getString("uuid"));
         Instant chatTimestamp = resultSet.getTimestamp("time_stamp").toInstant();
         String server = resultSet.getString("server");
+        String stringType = resultSet.getString("type");
+        ChatLogType type;
+        try {
+            type = ChatLogTypeMapper.fromDb(stringType);
+        } catch (Exception e) {
+            log.error("Failed to load chat log from result set: {}", e.getMessage());
+            return Optional.empty();
+        }
+        String channel = resultSet.getString("channel");
+        String receiver = resultSet.getString("receiver");
         String chatMessage = resultSet.getString("chat_message");
+        String stringMiniMessage = resultSet.getString("mini_message");
+        Component miniMessage = stringMiniMessage == null ? null : GsonComponentSerializer.gson().deserialize(
+                stringMiniMessage);
         boolean chatMessageBlocked = resultSet.getInt("blocked") == 1;
-        return new ChatLog(chatLogUUID, chatTimestamp, server, chatMessage, chatMessageBlocked);
+        return Optional.of(new ChatLog(chatLogUUID,
+                chatTimestamp,
+                server,
+                type,
+                channel,
+                receiver,
+                chatMessage,
+                miniMessage,
+                chatMessageBlocked
+        ));
     }
 
-    public void addChatLog(UUID uuid, String server, String message, boolean blocked) {
+    public void addChatLog(UUID uuid, String server, String message, ChatLogType chatLogType, String channel, String receiver, Component miniMessage, boolean blocked) {
-        addLog(new ChatLog(uuid, Instant.now(), server, message, blocked));
+        ChatLog chatLog = new ChatLog(uuid,
+                Instant.now(),
+                server,
+                chatLogType,
+                channel,
+                receiver,
+                message,
+                miniMessage,
+                blocked
+        );
+        addLog(chatLog);
+        chatLogWebHandler.forwardChatLogToWeb(chatLog);
     }
 
     public CompletableFuture<List<ChatLog>> retrieveChatLogs(UUID uuid, Duration duration, String server) {

api/src/main/java/com/alttd/chat/objects/chat_log/ChatLogMapper.java

@@ -0,0 +1,50 @@
+package com.alttd.chat.objects.chat_log;
+
+import com.alttd.altitudeweb.model.ChatMessageDto;
+import jakarta.validation.ConstraintViolation;
+import jakarta.validation.Validation;
+import jakarta.validation.Validator;
+import jakarta.validation.ValidatorFactory;
+import lombok.experimental.UtilityClass;
+import lombok.extern.slf4j.Slf4j;
+import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
+
+import java.time.ZoneOffset;
+import java.util.Optional;
+import java.util.Set;
+
+@Slf4j
+@UtilityClass
+public class ChatLogMapper {
+
+    ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
+    Validator validator = factory.getValidator();
+
+    public Optional<ChatMessageDto> toDto(ChatLog chatLog) {
+        ChatMessageDto chatMessageDto = new ChatMessageDto();
+        if (chatLog.getMiniMessage() == null) {
+            throw new IllegalArgumentException("MiniMessage cannot be null");
+        }
+        chatMessageDto.setUuid(chatLog.getUuid());
+        chatMessageDto.setTimestamp(chatLog.getTimestamp().atOffset(ZoneOffset.UTC));
+        chatMessageDto.setServer(chatLog.getServer());
+        chatMessageDto.setType(ChatLogTypeMapper.toDto(chatLog.getType()));
+        chatMessageDto.setChannel(chatLog.getChannel());
+        chatMessageDto.setReceiver(chatLog.getReceiver());
+        chatMessageDto.setMessage(GsonComponentSerializer.gson().serialize(chatLog.getMiniMessage()));
+        chatMessageDto.setBlocked(chatLog.isBlocked());
+        if (checkIsInvalid(chatMessageDto)) {
+            return Optional.empty();
+        }
+        return Optional.of(chatMessageDto);
+    }
+
+    private boolean checkIsInvalid(ChatMessageDto chatMessageDto) {
+        Set<ConstraintViolation<ChatMessageDto>> violations = validator.validate(chatMessageDto);
+        if (violations.isEmpty()) {
+            return false;
+        }
+        log.error("Validation failed for chat message: {}, {}", chatMessageDto, violations);
+        return true;
+    }
+}

api/src/main/java/com/alttd/chat/objects/chat_log/ChatLogType.java

@@ -0,0 +1,10 @@
+package com.alttd.chat.objects.chat_log;
+
+public enum ChatLogType {
+    PUBLIC,
+    GLOBAL,
+    PARTY,
+    GAC,
+    MSG,
+    CUSTOM;
+}

api/src/main/java/com/alttd/chat/objects/chat_log/ChatLogTypeMapper.java

@@ -0,0 +1,43 @@
+package com.alttd.chat.objects.chat_log;
+
+import com.alttd.altitudeweb.model.ChatMessageDto;
+import lombok.experimental.UtilityClass;
+
+@UtilityClass
+public class ChatLogTypeMapper {
+
+    public static String toDb(ChatLogType chatLogType) {
+        return switch (chatLogType) {
+            case PUBLIC -> "public";
+            case GLOBAL -> "global";
+            case PARTY -> "party";
+            case GAC -> "gac";
+            case MSG -> "msg";
+            case CUSTOM -> "custom";
+        };
+    }
+
+    public ChatMessageDto.TypeEnum toDto(ChatLogType chatLogType) {
+        return switch (chatLogType) {
+            case PUBLIC -> ChatMessageDto.TypeEnum.PUBLIC;
+            case GLOBAL -> ChatMessageDto.TypeEnum.GLOBAL;
+            case PARTY -> ChatMessageDto.TypeEnum.PARTY;
+            case GAC -> ChatMessageDto.TypeEnum.GAC;
+            case MSG -> ChatMessageDto.TypeEnum.MSG;
+            case CUSTOM -> ChatMessageDto.TypeEnum.CUSTOM;
+        };
+    }
+
+    public ChatLogType fromDb(String dbType) {
+        return switch (dbType) {
+            case "public" -> ChatLogType.PUBLIC;
+            case "global" -> ChatLogType.GLOBAL;
+            case "party" -> ChatLogType.PARTY;
+            case "gac" -> ChatLogType.GAC;
+            case "msg" -> ChatLogType.MSG;
+            case "custom" -> ChatLogType.CUSTOM;
+            default -> throw new IllegalArgumentException("Invalid chat log type: " + dbType);
+        };
+    }
+
+}

api/src/main/java/com/alttd/chat/objects/chat_log/ChatLogWebHandler.java

@@ -0,0 +1,102 @@
+package com.alttd.chat.objects.chat_log;
+
+import com.alttd.altitudeweb.api.ChatApi;
+import com.alttd.altitudeweb.invoker.ApiClient;
+import com.alttd.altitudeweb.invoker.ApiException;
+import com.alttd.altitudeweb.model.ChatMessageDto;
+import com.alttd.chat.config.Config;
+import com.alttd.chat.util.ALogger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class ChatLogWebHandler {
+
+    private static final int MAX_QUEUE_SIZE = 100;
+    private static final Logger log = LoggerFactory.getLogger(ChatLogWebHandler.class);
+
+    private final Queue<ChatLog> queue = new ConcurrentLinkedQueue<>();
+    private final ExecutorService executor = Executors.newSingleThreadExecutor();
+
+    private final ChatApi chatApi;
+
+    public ChatLogWebHandler() {
+        ApiClient apiClient = new ApiClient();
+        apiClient.setBasePath(Config.CHAT_WEB_SERVER_BASE_URL);
+
+        chatApi = new ChatApi(apiClient);
+    }
+
+    private volatile boolean sending;
+
+    public void forwardChatLogToWeb(ChatLog chatLog) {
+        if (queue.size() >= MAX_QUEUE_SIZE) {
+            queue.clear();
+            log.error("Chat log queue overflow, is the web backend still running?");
+        }
+
+        queue.add(chatLog);
+        triggerSend();
+    }
+
+    private void triggerSend() {
+        if (sending) {
+            return;
+        }
+
+        synchronized (this) {
+            if (sending || queue.isEmpty()) {
+                return;
+            }
+
+            sending = true;
+        }
+
+        executor.execute(this::sendBatch);
+    }
+
+    private void sendBatch() {
+        try {
+            ArrayList<ChatLog> chatLogList = new ArrayList<>();
+
+            ChatLog log;
+            while ((log = queue.poll()) != null) {
+                if (log.getMiniMessage() == null) {
+                    ALogger.warn("No mini message for message, skipping");
+                    continue;
+                }
+                chatLogList.add(log);
+            }
+
+            List<ChatMessageDto> batch = chatLogList.stream()
+                    .map(ChatLogMapper::toDto)
+                    .filter(Optional::isPresent)
+                    .map(Optional::get)
+                    .toList();
+
+            if (!chatLogList.isEmpty()) {
+                try {
+                    chatApi.sendChatMessages(batch);
+                } catch (ApiException e) {
+                    ALogger.error("Failed to send chat messages to web backend, " +
+                                  "adding messages back to queue for another try", e
+                    );
+                    queue.addAll(chatLogList);
+                }
+            }
+        } finally {
+            synchronized (this) {
+                sending = false;
+            }
+
+            triggerSend();
+        }
+    }
+}

build.gradle.kts

@@ -1,6 +1,6 @@
 plugins {
     `java-library`
-    id("io.github.goooler.shadow") version "8.1.8"
+    id("com.gradleup.shadow") version "9.6.1"
     id("com.github.ben-manes.versions") version "0.52.0"
 }
 
@@ -15,7 +15,7 @@ subprojects {
 
     java {
         toolchain {
-            languageVersion.set(JavaLanguageVersion.of(21))
+            languageVersion.set(JavaLanguageVersion.of(25))
         }
     }
 

galaxy/build.gradle.kts

@@ -1,6 +1,6 @@
 plugins {
     `maven-publish`
-    id("io.github.goooler.shadow")
+    id("com.gradleup.shadow")
 }
 
 val nexusUser = providers.gradleProperty("alttdSnapshotUsername").orNull ?: System.getenv("NEXUS_USERNAME")
@@ -8,9 +8,9 @@ val nexusPass = providers.gradleProperty("alttdSnapshotPassword").orNull ?: Syst
 
 dependencies {
     implementation(project(":api")) // API
-    compileOnly("com.alttd.cosmos:cosmos-api:1.21.8-R0.1-SNAPSHOT") {
+    compileOnly("com.alttd.cosmos:cosmos-api:26.2.build.17-stable")
-        isChanging = true
+    compileOnly("org.projectlombok:lombok:1.18.46")
-    }
+    annotationProcessor("org.projectlombok:lombok:1.18.46")
     compileOnly("com.gitlab.ruany:LiteBansAPI:0.6.1") // move to proxy
     compileOnly("org.apache.commons:commons-lang3:3.17.0") // needs an alternative, already removed from upstream api and will be removed in server
     compileOnly("net.luckperms:api:5.5") // Luckperms

galaxy/src/main/java/com/alttd/chat/ChatPlugin.java

@@ -35,11 +35,15 @@ public class ChatPlugin extends JavaPlugin {
         instance = this;
         ALogger.init(getSLF4JLogger());
         chatAPI = new ChatImplementation();
-        chatHandler = new ChatHandler();
+        ChatLogHandler chatLogHandler = ChatLogHandler.getInstance(true);
+        chatHandler = new ChatHandler(chatLogHandler);
         DatabaseConnection.initialize();
         serverConfig = new ServerConfig(ServerName.getServerName());
-        ChatLogHandler chatLogHandler = ChatLogHandler.getInstance(true);
+        registerListener(new PlayerListener(serverConfig),
-        registerListener(new PlayerListener(serverConfig), new ChatListener(chatLogHandler), new BookListener(), new ShutdownListener(chatLogHandler, this));
+                new ChatListener(chatLogHandler),
+                new BookListener(),
+                new ShutdownListener(chatLogHandler, this)
+        );
         if (serverConfig.GLOBALCHAT) {
             registerCommand("globalchat", new GlobalChat());
             registerCommand("toggleglobalchat", new ToggleGlobalChat());
@@ -58,12 +62,15 @@ public class ChatPlugin extends JavaPlugin {
             if (!(channel instanceof CustomChannel customChannel)) {
                 continue;
             }
-            this.getServer().getCommandMap().register(channel.getChannelName().toLowerCase(), new ChatChannel(customChannel));
+            this.getServer()
+                    .getCommandMap()
+                    .register(channel.getChannelName().toLowerCase(), new ChatChannel(customChannel));
         }
 
         String messageChannel = Config.MESSAGECHANNEL;
         getServer().getMessenger().registerOutgoingPluginChannel(this, messageChannel);
-        getServer().getMessenger().registerIncomingPluginChannel(this, messageChannel, new PluginMessage());
+        getServer().getMessenger()
+                .registerIncomingPluginChannel(this, messageChannel, new PluginMessage(chatLogHandler));
 
         NicknamesEvents nicknamesEvents = new NicknamesEvents();
         getServer().getMessenger().registerIncomingPluginChannel(this, messageChannel, nicknamesEvents);
@@ -110,7 +117,9 @@ public class ChatPlugin extends JavaPlugin {
         chatAPI.reloadConfig();
         chatAPI.reloadChatFilters();
         serverConfig = new ServerConfig(ServerName.getServerName());
-        Bukkit.broadcast(Utility.parseMiniMessage("Reloaded ChatPlugin Config.").asComponent(), "command.chat.reloadchat");
+        Bukkit.broadcast(Utility.parseMiniMessage("Reloaded ChatPlugin Config.").asComponent(),
+                "command.chat.reloadchat"
+        );
         ALogger.info("Reloaded ChatPlugin config.");
     }
 }

galaxy/src/main/java/com/alttd/chat/handler/ChatHandler.java

@@ -8,6 +8,8 @@ import com.alttd.chat.objects.ChatFilter;
 import com.alttd.chat.objects.ChatUser;
 import com.alttd.chat.objects.ModifiableString;
 import com.alttd.chat.objects.channels.CustomChannel;
+import com.alttd.chat.objects.chat_log.ChatLogHandler;
+import com.alttd.chat.objects.chat_log.ChatLogType;
 import com.alttd.chat.util.ALogger;
 import com.alttd.chat.util.GalaxyUtility;
 import com.alttd.chat.util.ServerName;
@@ -28,6 +30,7 @@ import org.bukkit.Material;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
+import org.jspecify.annotations.Nullable;
 
 import java.util.List;
 import java.util.Objects;
@@ -40,8 +43,10 @@ public class ChatHandler {
     private final ChatPlugin plugin;
 
     private final ComponentLike GCNOTENABLED;
+    private final ChatLogHandler chatLogHandler;
 
-    public ChatHandler() {
+    public ChatHandler(ChatLogHandler chatLogHandler) {
+        this.chatLogHandler = chatLogHandler;
         plugin = ChatPlugin.getInstance();
         GCNOTENABLED = Utility.parseMiniMessage(Config.GCNOTENABLED);
     }
@@ -64,7 +69,8 @@ public class ChatHandler {
             GalaxyUtility.sendBlockedNotification("DM Language",
                     player,
                     Utility.parseMiniMessage(Utility.parseColors(modifiableString.string())),
-                                                  target);
+                    target
+            );
             return; // the message was blocked
         }
 
@@ -73,7 +79,8 @@ public class ChatHandler {
         sendPrivateMessage(player, target, "privatemessage", component.asComponent());
         ComponentLike spymessage = Utility.parseMiniMessage(Config.MESSAGESPY, placeholders);
         for (Player pl : Bukkit.getOnlinePlayers()) {
-            if (pl.hasPermission(Config.SPYPERMISSION) && ChatUserManager.getChatUser(pl.getUniqueId()).isSpy() && !pl.equals(player) && !pl.getName().equalsIgnoreCase(target)) {
+            if (pl.hasPermission(Config.SPYPERMISSION) && ChatUserManager.getChatUser(pl.getUniqueId())
+                    .isSpy() && !pl.equals(player) && !pl.getName().equalsIgnoreCase(target)) {
                 pl.sendMessage(spymessage);
             }
         }
@@ -96,7 +103,8 @@ public class ChatHandler {
             GalaxyUtility.sendBlockedNotification("DM Language",
                     player,
                     Utility.parseMiniMessage(Utility.parseColors(modifiableString.string())),
-                                                  target);
+                    target
+            );
             return; // the message was blocked
         }
 
@@ -108,7 +116,8 @@ public class ChatHandler {
         sendPrivateMessage(player, target, "privatemessage", messageComponent);
         ComponentLike spymessage = Utility.parseMiniMessage(Config.MESSAGESPY, placeholders);
         for (Player pl : Bukkit.getOnlinePlayers()) {
-            if (pl.hasPermission(Config.SPYPERMISSION) && ChatUserManager.getChatUser(pl.getUniqueId()).isSpy() && !pl.equals(player) && !pl.getName().equalsIgnoreCase(target)) {
+            if (pl.hasPermission(Config.SPYPERMISSION) && ChatUserManager.getChatUser(pl.getUniqueId())
+                    .isSpy() && !pl.equals(player) && !pl.getName().equalsIgnoreCase(target)) {
                 pl.sendMessage(spymessage);
             }
         }
@@ -127,7 +136,9 @@ public class ChatHandler {
 
         long timeLeft = TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis() - user.getGcCooldown());
         if (timeLeft <= Config.GCCOOLDOWN && !player.hasPermission("chat.globalchat.cooldownbypass")) { // player is on cooldown and should wait x seconds
-            player.sendRichMessage(Config.GCONCOOLDOWN, Placeholder.parsed("cooldown", Config.GCCOOLDOWN - timeLeft + ""));
+            player.sendRichMessage(Config.GCONCOOLDOWN,
+                    Placeholder.parsed("cooldown", Config.GCCOOLDOWN - timeLeft + "")
+            );
             return;
         }
 
@@ -148,11 +159,22 @@ public class ChatHandler {
             GalaxyUtility.sendBlockedNotification("GC Language",
                     player,
                     Utility.parseMiniMessage(Utility.parseColors(modifiableString.string())),
-                                                  "");
+                    ""
+            );
             return; // the message was blocked
         }
         component = modifiableString.component();
 
+        chatLogHandler.addChatLog(player.getUniqueId(),
+                Bukkit.getServerName(),
+                message,
+                ChatLogType.GLOBAL,
+                null,
+                null,
+                component,
+                false
+        );
+
         user.setGcCooldown(System.currentTimeMillis());
         sendPluginMessage(player, "globalchat", component);
     }
@@ -180,11 +202,16 @@ public class ChatHandler {
         Component component = Utility.parseMiniMessage(channel.getFormat(), placeholders).asComponent();
 
         ModifiableString modifiableString = new ModifiableString(component);
-        if (!RegexManager.filterText(player.getName(), player.getUniqueId(), modifiableString, channel.getChannelName())) {
+        if (!RegexManager.filterText(player.getName(),
+                player.getUniqueId(),
+                modifiableString,
+                channel.getChannelName()
+        )) {
             GalaxyUtility.sendBlockedNotification(channel.getChannelName() + " Language",
                     player,
                     Utility.parseMiniMessage(Utility.parseColors(modifiableString.string())),
-                                                  "");
+                    ""
+            );
             ALogger.info("Refusing to send blocked chat message");
             return;
         }
@@ -255,16 +282,20 @@ public class ChatHandler {
 
         if (!chatChannel.getServers().contains(ServerName.getServerName())) {
             player.sendRichMessage("<red>Unable to send messages to <channel> in this server.</red>",
-                                   Placeholder.parsed("channel", chatChannel.getChannelName()));
+                    Placeholder.parsed("channel", chatChannel.getChannelName())
+            );
             ALogger.info(String.format("Not sending chat message due to [%s] not being in this channels config",
-                                       ServerName.getServerName()));
+                    ServerName.getServerName()
+            ));
             return;
         }
 
         Stream<? extends Player> stream = Bukkit.getServer().getOnlinePlayers().stream()
                 .filter(p -> p.hasPermission(chatChannel.getPermission()));
         if (!player.hasPermission("chat.ignorebypass")) {
-            stream = stream.filter(receiver -> !ChatUserManager.getChatUser(receiver.getUniqueId()).getIgnoredPlayers().contains(uuid)
+            stream = stream.filter(receiver -> !ChatUserManager.getChatUser(receiver.getUniqueId())
+                    .getIgnoredPlayers()
+                    .contains(uuid)
                                                || receiver.hasPermission("chat.ignorebypass"));
         }
         if (chatChannel.isLocal()) {
@@ -283,6 +314,16 @@ public class ChatHandler {
         List<? extends Player> recipientPlayers = stream.toList();
         recipientPlayers.forEach(p -> p.sendMessage(component));
 
+        chatLogHandler.addChatLog(player.getUniqueId(),
+                Bukkit.getServerName(),
+                message,
+                ChatLogType.CUSTOM,
+                chatChannel.getChannelName(),
+                getLocationIfLocal(chatChannel, player),
+                component.asComponent(),
+                false
+        );
+
         List<UUID> recipientUUIDs = recipientPlayers.stream().map(Entity::getUniqueId).toList();
         Bukkit.getServer().getOnlinePlayers().stream()
                 .filter(onlinePlayer -> onlinePlayer.hasPermission(Config.SPYPERMISSION))
@@ -290,7 +331,22 @@ public class ChatHandler {
                 .forEach(onlinePlayer -> onlinePlayer.sendRichMessage(Config.CHANNEL_SPY,
                         Placeholder.component("sender", player.name()),
                         Placeholder.parsed("channel", chatChannel.getChannelName()),
-                                                                      Placeholder.parsed("message", message)));
+                        Placeholder.parsed("message", message)
+                ));
+    }
+
+    private static @Nullable String getLocationIfLocal(CustomChannel chatChannel, Player player) {
+        if (!chatChannel.isLocal()) {
+            return null;
+        }
+        String format = String.format("%s;%s",
+                player.getLocation().getBlockX(),
+                player.getLocation().getBlockZ()
+        );
+        if (format.length() > 36) {
+            return null;
+        }
+        return format;
     }
 
     private void sendPluginMessage(Player player, String channel, Component component) {
@@ -326,9 +382,14 @@ public class ChatHandler {
         if (user == null) {
             return false;
         }
-        if (user.isMuted() || (ChatPlugin.getInstance().serverMuted() && !player.hasPermission("chat.bypass-server-muted"))) {
+        if (user.isMuted() || (ChatPlugin.getInstance().serverMuted() && !player.hasPermission(
+                "chat.bypass-server-muted"))) {
             //        if (Database.get().isPlayerMuted(player.getUniqueId(), null) || (ChatPlugin.getInstance().serverMuted() && !player.hasPermission("chat.bypass-server-muted"))) {
-            GalaxyUtility.sendBlockedNotification(prefix, player, Utility.parseMiniMessage(Utility.stripTokens(message)), "");
+            GalaxyUtility.sendBlockedNotification(prefix,
+                    player,
+                    Utility.parseMiniMessage(Utility.stripTokens(message)),
+                    ""
+            );
             return true;
         }
         return false;

galaxy/src/main/java/com/alttd/chat/listeners/ChatListener.java

@@ -7,6 +7,7 @@ import com.alttd.chat.managers.ChatUserManager;
 import com.alttd.chat.managers.RegexManager;
 import com.alttd.chat.objects.*;
 import com.alttd.chat.objects.chat_log.ChatLogHandler;
+import com.alttd.chat.objects.chat_log.ChatLogType;
 import com.alttd.chat.util.ALogger;
 import com.alttd.chat.util.GalaxyUtility;
 import com.alttd.chat.util.ServerName;
@@ -55,9 +56,14 @@ public class ChatListener implements Listener {
         }
 
         Component formatComponent = Component.text("%message%");
-        ComponentLike message = parseMessageContent(event.player(), plainTextComponentSerializer.serialize(event.originalMessage()));
+        ComponentLike message = parseMessageContent(event.player(),
+                plainTextComponentSerializer.serialize(event.originalMessage())
+        );
 
-        event.result(formatComponent.replaceText(TextReplacementConfig.builder().match("%message%").replacement(message).build()));
+        event.result(formatComponent.replaceText(TextReplacementConfig.builder()
+                .match("%message%")
+                .replacement(message)
+                .build()));
     }
 
     @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
@@ -67,9 +73,14 @@ public class ChatListener implements Listener {
         }
 
         Component formatComponent = Component.text("%message%");
-        ComponentLike message = parseMessageContent(event.player(), plainTextComponentSerializer.serialize(event.originalMessage()));
+        ComponentLike message = parseMessageContent(event.player(),
+                plainTextComponentSerializer.serialize(event.originalMessage())
+        );
 
-        event.result(formatComponent.replaceText(TextReplacementConfig.builder().match("%message%").replacement(message).build()));
+        event.result(formatComponent.replaceText(TextReplacementConfig.builder()
+                .match("%message%")
+                .replacement(message)
+                .build()));
     }
 
     private final Component mention = MiniMessage.miniMessage().deserialize(Config.MENTIONPLAYERTAG);
@@ -92,8 +103,9 @@ public class ChatListener implements Listener {
         UUID uuid = player.getUniqueId();
 
         ComponentLike input = event.message().colorIfAbsent(NamedTextColor.WHITE);
+        Component inputComponent = input.asComponent();
 
-        ModifiableString modifiableString = new ModifiableString(input.asComponent());
+        ModifiableString modifiableString = new ModifiableString(inputComponent);
 
         // todo a better way for this
         if (!RegexManager.filterText(player.getName(), uuid, modifiableString, true, "chat", filterType -> {
@@ -107,12 +119,23 @@ public class ChatListener implements Listener {
                     out.writeUTF(uuid.toString());
                     out.writeUTF(modifiableString.string());
                     player.sendPluginMessage(ChatPlugin.getInstance(), Config.MESSAGECHANNEL, out.toByteArray());
-        })) {
+                }
+        )) {
             event.setCancelled(true);
             GalaxyUtility.sendBlockedNotification("Language", player,
                     modifiableString.component(),
-                                                  "");
+                    ""
-            chatLogHandler.addChatLog(uuid, ServerName.getServerName(), PlainTextComponentSerializer.plainText().serialize(input.asComponent()), true);
+            );
+            String originalMessage = PlainTextComponentSerializer.plainText().serialize(inputComponent);
+            chatLogHandler.addChatLog(uuid,
+                    ServerName.getServerName(),
+                    originalMessage,
+                    ChatLogType.PUBLIC,
+                    null,
+                    null,
+                    render(player, inputComponent).asComponent(),
+                    true
+            );
             return; // the message was blocked
         }
 
@@ -120,8 +143,13 @@ public class ChatListener implements Listener {
                 .map(audience -> (Player) audience);
 
         if (!player.hasPermission("chat.ignorebypass")) {
-            stream = stream.filter(receiver -> !ChatUserManager.getChatUser(receiver.getUniqueId()).getIgnoredPlayers().contains(uuid)
+            stream = stream.filter(receiver -> {
-                                               || receiver.hasPermission("chat.ignorebypass"));
+                boolean isPlayerIgnored = ChatUserManager
+                        .getChatUser(receiver.getUniqueId())
+                        .getIgnoredPlayers()
+                        .contains(uuid);
+                return !isPlayerIgnored || receiver.hasPermission("chat.ignorebypass");
+            });
         }
         Set<Player> receivers = stream.collect(Collectors.toSet());
 
@@ -135,8 +163,16 @@ public class ChatListener implements Listener {
         for (Player pingPlayer : playersToPing) {
             pingPlayer.playSound(pingPlayer.getLocation(), Sound.BLOCK_NOTE_BLOCK_BASS, 1, 1);
         }
-        chatLogHandler.addChatLog(uuid, ServerName.getServerName(), modifiableString.string(), false);
+        chatLogHandler.addChatLog(uuid,
-        ALogger.info(PlainTextComponentSerializer.plainText().serialize(input.asComponent()));
+                ServerName.getServerName(),
+                modifiableString.string(),
+                ChatLogType.PUBLIC,
+                null,
+                null,
+                input.asComponent(),
+                false
+        );
+        ALogger.info(PlainTextComponentSerializer.plainText().serialize(inputComponent));
     }
 
     private void pingPlayers(Set<Player> playersToPing, ModifiableString modifiableString, Player player) {
@@ -165,7 +201,9 @@ public class ChatListener implements Listener {
                 //                            return ;
                 //                        });
 
-                if (!ChatUserManager.getChatUser(onlinePlayer.getUniqueId()).getIgnoredPlayers().contains(player.getUniqueId())
+                if (!ChatUserManager.getChatUser(onlinePlayer.getUniqueId())
+                        .getIgnoredPlayers()
+                        .contains(player.getUniqueId())
                     || player.hasPermission("chat.ignorebypass")) {
                     playersToPing.add(onlinePlayer);
                 }
@@ -175,7 +213,9 @@ public class ChatListener implements Listener {
                         .match(nickPattern)
                         .replacement(mention.append(onlinePlayerUser.getDisplayName()))
                         .build());
-                if (!ChatUserManager.getChatUser(onlinePlayer.getUniqueId()).getIgnoredPlayers().contains(player.getUniqueId())
+                if (!ChatUserManager.getChatUser(onlinePlayer.getUniqueId())
+                        .getIgnoredPlayers()
+                        .contains(player.getUniqueId())
                     || player.hasPermission("chat.ignorebypass")) {
                     playersToPing.add(onlinePlayer);
                 }

galaxy/src/main/java/com/alttd/chat/listeners/PluginMessage.java

@@ -10,6 +10,8 @@ import com.alttd.chat.objects.Party;
 import com.alttd.chat.objects.PartyUser;
 import com.alttd.chat.objects.channels.Channel;
 import com.alttd.chat.objects.channels.CustomChannel;
+import com.alttd.chat.objects.chat_log.ChatLogHandler;
+import com.alttd.chat.objects.chat_log.ChatLogType;
 import com.alttd.chat.util.ALogger;
 import com.alttd.chat.util.ServerName;
 import com.alttd.chat.util.Utility;
@@ -18,6 +20,7 @@ import com.google.common.io.ByteStreams;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.ComponentLike;
 import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
+import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
 import org.bukkit.Bukkit;
 import org.bukkit.Sound;
 import org.bukkit.entity.Player;
@@ -29,6 +32,12 @@ import java.util.UUID;
 
 public class PluginMessage implements PluginMessageListener {
 
+    private final ChatLogHandler chatLogHandler;
+
+    public PluginMessage(ChatLogHandler chatLogHandler) {
+        this.chatLogHandler = chatLogHandler;
+    }
+
     @Override
     public void onPluginMessageReceived(String channel, @NotNull Player ignored, byte[] bytes) {
         if (!channel.equals(Config.MESSAGECHANNEL)) {
@@ -48,13 +57,25 @@ public class PluginMessage implements PluginMessageListener {
                 }
                 ChatUser chatUser = ChatUserManager.getChatUser(uuid);
                 if (isTargetNotIgnored(chatUser, targetuuid)) {
-                    player.sendMessage(GsonComponentSerializer.gson().deserialize(message));
+                    Component component = GsonComponentSerializer.gson().deserialize(message);
+                    player.sendMessage(component);
                     player.playSound(player.getLocation(), Sound.BLOCK_NOTE_BLOCK_BASS, 1,
-                                     1); // todo load this from config
+                            1
+                    ); // todo load this from config
                     ChatUser user = ChatUserManager.getChatUser(uuid);
                     if (!user.getReplyContinueTarget().equalsIgnoreCase(target)) {
                         user.setReplyTarget(target);
                     }
+                    // Handled here since this is after the ignore check and is only send once
+                    chatLogHandler.addChatLog(uuid,
+                            ServerName.getServerName(),
+                            PlainTextComponentSerializer.plainText().serialize(component),
+                            ChatLogType.MSG,
+                            null,
+                            player.getUniqueId().toString(),
+                            component,
+                            false
+                    );
                 }
             }
             case "privatemessageout" -> {
@@ -69,9 +90,18 @@ public class PluginMessage implements PluginMessageListener {
                 ChatUser chatUser = ChatUserManager.getChatUser(uuid);
                 if (isTargetNotIgnored(chatUser, targetuuid)) {
                     chatUser.setReplyTarget(target);
-                    player.sendMessage(GsonComponentSerializer.gson().deserialize(message));
+                    Component component = GsonComponentSerializer.gson().deserialize(message);
-                    //                        ChatUser user = ChatUserManager.getChatUser(uuid);
+                    player.sendMessage(component);
-                    //                        user.setReplyTarget(target);
+                    // Handled here since this is after the ignore check and is only send once
+                    chatLogHandler.addChatLog(uuid,
+                            ServerName.getServerName(),
+                            PlainTextComponentSerializer.plainText().serialize(component),
+                            ChatLogType.MSG,
+                            null,
+                            player.getUniqueId().toString(),
+                            component,
+                            false
+                    );
                 }
             }
             case "globalchat" -> {
@@ -82,10 +112,11 @@ public class PluginMessage implements PluginMessageListener {
                 UUID uuid = UUID.fromString(in.readUTF());
                 String message = in.readUTF();
 
+                Component component = GsonComponentSerializer.gson().deserialize(message);
                 Bukkit.getOnlinePlayers().stream().filter(p -> p.hasPermission(Config.GCPERMISSION)).forEach(p -> {
                     ChatUser chatUser = ChatUserManager.getChatUser(p.getUniqueId());
                     if (isTargetNotIgnored(chatUser, uuid)) {
-                        p.sendMessage(GsonComponentSerializer.gson().deserialize(message));
+                        p.sendMessage(component);
                     }
                 });
             }
@@ -107,6 +138,7 @@ public class PluginMessage implements PluginMessageListener {
                 }
 
                 chatChannel(in);
+                //TODO [Stijn] [2026-07-19]: handle custom channels
             }
             case "tmppartyupdate" -> {
                 int id = Integer.parseInt(in.readUTF());

galaxy/src/main/java/com/alttd/chat/nicknames/NicknamesEvents.java

@@ -119,8 +119,7 @@ public class NicknamesEvents implements Listener, PluginMessageListener {
         switch (subChannel) {
             case "NickNameRequest":
                 ComponentLike component = miniMessage.deserialize(Config.NICK_REQUEST_NEW, Placeholder.parsed("player", name))
-                        .clickEvent(ClickEvent.clickEvent(ClickEvent.Action.RUN_COMMAND,
+                        .clickEvent(ClickEvent.runCommand("/nick review"))
-                                                          "/nick review"))
                         .hoverEvent(HoverEvent.hoverEvent(HoverEvent.Action.SHOW_TEXT,
                                                           miniMessage.deserialize("<gold>Click this text to review the request!")));
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

gradlew

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 #
-# Copyright © 2015-2021 the original authors.
+# Copyright © 2015 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
 #
@@ -55,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/b631911858264c0b6e4d6603d677ff5218766cee/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -84,7 +86,7 @@ done
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
 # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -112,7 +114,6 @@ case "$( uname )" in                #(
   NONSTOP* )        nonstop=true ;;
 esac
 
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 
 # Determine the Java command to use to start the JVM.
@@ -170,7 +171,6 @@ fi
 # For Cygwin or MSYS, switch paths to Windows format before running java
 if "$cygwin" || "$msys" ; then
     APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
 
     JAVACMD=$( cygpath --unix "$JAVACMD" )
 
@@ -203,15 +203,14 @@ fi
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Collect all arguments for the java command:
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
 #     and any embedded shellness will be escaped.
 #   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
 #     treated as '${Hostname}' itself on the command line.
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
-        org.gradle.wrapper.GradleWrapperMain \
         "$@"
 
 # Stop when "xargs" is not available.

gradlew.bat

@@ -13,6 +13,8 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
 @if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
@@ -43,11 +45,11 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute
 
-echo.
+echo. 1>&2
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
-echo.
+echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation.
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -57,22 +59,21 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo.
+echo. 1>&2
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
-echo.
+echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation.
+echo location of your Java installation. 1>&2
 
 goto fail
 
 :execute
 @rem Setup the command line
 
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
 
 :end
 @rem End local scope for the variables with windows NT shell

settings.gradle.kts

@@ -19,13 +19,19 @@ dependencyResolutionManagement {
         maven("https://repo.extendedclip.com/content/repositories/placeholderapi/") // Papi
         maven("https://jitpack.io")
         maven {
-            name = "nexus"
             url = uri("https://repo.alttd.com/repository/alttd-snapshot/")
             credentials {
                 username = nexusUser
                 password = nexusPass
             }
         }
+        maven {
+            url = uri("https://repo.alttd.com/repository/alttd/")
+            credentials {
+                username = nexusUser
+                password = nexusPass
+            }
+        }
     }
     repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
 }
@@ -35,3 +41,5 @@ pluginManagement {
         gradlePluginPortal()
     }
 }
+
+include("web-api")

velocity/build.gradle.kts

@@ -1,10 +1,12 @@
 plugins {
     `maven-publish`
-    id("io.github.goooler.shadow")
+    id("com.gradleup.shadow")
 }
 
 dependencies {
     implementation(project(":api")) // API
+    compileOnly("org.projectlombok:lombok:1.18.46")
+    annotationProcessor("org.projectlombok:lombok:1.18.46")
     compileOnly("com.velocitypowered:velocity-api:3.5.0-SNAPSHOT")
     annotationProcessor("com.velocitypowered:velocity-api:3.5.0-SNAPSHOT")
     implementation("mysql:mysql-connector-java:8.0.33") // mysql

velocity/src/main/java/com/alttd/velocitychat/VelocityChat.java

@@ -2,20 +2,20 @@ package com.alttd.velocitychat;
 
 import com.alttd.chat.ChatAPI;
 import com.alttd.chat.ChatImplementation;
+import com.alttd.chat.config.Config;
+import com.alttd.chat.database.DatabaseConnection;
 import com.alttd.chat.managers.ChatUserManager;
 import com.alttd.chat.managers.PartyManager;
 import com.alttd.chat.objects.ChatUser;
 import com.alttd.chat.objects.chat_log.ChatLogHandler;
+import com.alttd.chat.util.ALogger;
 import com.alttd.velocitychat.commands.*;
-import com.alttd.chat.config.Config;
-import com.alttd.chat.database.DatabaseConnection;
 import com.alttd.velocitychat.handlers.ChatHandler;
 import com.alttd.velocitychat.handlers.ServerHandler;
 import com.alttd.velocitychat.listeners.ChatListener;
 import com.alttd.velocitychat.listeners.LiteBansListener;
-import com.alttd.velocitychat.listeners.ProxyPlayerListener;
 import com.alttd.velocitychat.listeners.PluginMessageListener;
-import com.alttd.chat.util.ALogger;
+import com.alttd.velocitychat.listeners.ProxyPlayerListener;
 import com.google.common.io.ByteArrayDataOutput;
 import com.google.common.io.ByteStreams;
 import com.google.inject.Inject;
@@ -36,7 +36,7 @@ import java.nio.file.Path;
         description = "A chat plugin for Altitude Minecraft Server",
         authors = {"destro174", "teri"},
         dependencies = {@Dependency(id = "luckperms"), @Dependency(id = "litebans"), @Dependency(id = "proxydiscordlink")}
-        )
+)
 public class VelocityChat {
 
     private static VelocityChat plugin;
@@ -67,7 +67,8 @@ public class VelocityChat {
         PartyManager.initialize(); // load the parties from the db and add the previously loaded users to them
 
         serverHandler = new ServerHandler();
-        chatHandler = new ChatHandler();
+        ChatLogHandler chatLogHandler = new ChatLogHandler(true);
+        chatHandler = new ChatHandler(chatLogHandler);
         server.getEventManager().register(this, new ChatListener());
         server.getEventManager().register(this, new ProxyPlayerListener());
         new LiteBansListener().init(); // init the litebans api listeners
@@ -89,7 +90,11 @@ public class VelocityChat {
         ByteArrayDataOutput buf = ByteStreams.newDataOutput();
         buf.writeUTF("reloadconfig");
         ALogger.info("Reloaded ChatPlugin proxy config.");
-        getProxy().getAllServers().stream().forEach(registeredServer -> registeredServer.sendPluginMessage(getChannelIdentifier(), buf.toByteArray()));
+        getProxy().getAllServers()
+                .stream()
+                .forEach(registeredServer -> registeredServer.sendPluginMessage(getChannelIdentifier(),
+                        buf.toByteArray()
+                ));
     }
 
     public File getDataDirectory() {

velocity/src/main/java/com/alttd/velocitychat/handlers/ChatHandler.java

@@ -6,6 +6,8 @@ import com.alttd.chat.managers.ChatUserManager;
 import com.alttd.chat.managers.PartyManager;
 import com.alttd.chat.managers.RegexManager;
 import com.alttd.chat.objects.*;
+import com.alttd.chat.objects.chat_log.ChatLogHandler;
+import com.alttd.chat.objects.chat_log.ChatLogType;
 import com.alttd.chat.util.ALogger;
 import com.alttd.chat.util.Utility;
 import com.alttd.velocitychat.VelocityChat;
@@ -32,6 +34,12 @@ import java.util.UUID;
 
 public class ChatHandler {
 
+    private final ChatLogHandler chatLogHandler;
+
+    public ChatHandler(ChatLogHandler chatLogHandler) {
+        this.chatLogHandler = chatLogHandler;
+    }
+
     public void privateMessage(String sender, String target, String message) {
         UUID uuid = UUID.fromString(sender);
         ChatUser senderUser = ChatUserManager.getChatUser(uuid);
@@ -54,15 +62,23 @@ public class ChatHandler {
                 Placeholder.component("receiver", targetUser.getDisplayName()),
                 Placeholder.unparsed("receivername", player2.getUsername()),
                 Placeholder.component("message", GsonComponentSerializer.gson().deserialize(message)),
-                Placeholder.unparsed("server", player.getCurrentServer().isPresent() ? player.getCurrentServer().get().getServerInfo().getName() : "Altitude"));
+                Placeholder.unparsed("server",
+                        player.getCurrentServer().isPresent() ? player.getCurrentServer()
+                                .get()
+                                .getServerInfo()
+                                .getName() : "Altitude"
+                )
+        );
 
         ServerConnection serverConnection;
+        //Log handled on receiving server since it is only received on one server and that's where the ignore check happens
         if (player.getCurrentServer().isPresent() && player2.getCurrentServer().isPresent()) {
             // redirect to the sender
             serverConnection = player.getCurrentServer().get();
             Component component = Utility.parseMiniMessage(Config.MESSAGESENDER
                     .replaceAll("<sendername>", player.getUsername())
-                                                                   .replaceAll("<receivername>", player2.getUsername()), Placeholders).asComponent();
+                    .replaceAll("<receivername>", player2.getUsername()), Placeholders
+            ).asComponent();
             ByteArrayDataOutput buf = ByteStreams.newDataOutput();
             buf.writeUTF("privatemessageout");
             buf.writeUTF(player.getUniqueId().toString());
@@ -75,7 +91,8 @@ public class ChatHandler {
             serverConnection = player2.getCurrentServer().get();
             component = Utility.parseMiniMessage(Config.MESSAGERECIEVER
                     .replaceAll("<sendername>", player.getUsername())
-                                                         .replaceAll("<receivername>", player2.getUsername()), Placeholders).asComponent();
+                    .replaceAll("<receivername>", player2.getUsername()), Placeholders
+            ).asComponent();
             buf = ByteStreams.newDataOutput();
             buf.writeUTF("privatemessagein");
             buf.writeUTF(player2.getUniqueId().toString());
@@ -134,7 +151,7 @@ public class ChatHandler {
         }
         ComponentLike senderName = user.getDisplayName();
 
-        TagResolver Placeholders = TagResolver.resolver(
+        TagResolver placeholders = TagResolver.resolver(
                 Placeholder.component("sender", senderName),
                 Placeholder.component("sendername", senderName),
                 Placeholder.unparsed("partyname", party.getPartyName()),
@@ -142,7 +159,7 @@ public class ChatHandler {
                 Placeholder.unparsed("server", serverConnection.getServer().getServerInfo().getName())
         );
 
-        Component partyMessage = Utility.parseMiniMessage(Config.PARTY_FORMAT, Placeholders).asComponent()
+        Component partyMessage = Utility.parseMiniMessage(Config.PARTY_FORMAT, placeholders).asComponent()
                 .replaceText(TextReplacementConfig.builder().once().matchLiteral("[i]").replacement(item).build());
 
         ModifiableString modifiableString = new ModifiableString(partyMessage);
@@ -155,7 +172,17 @@ public class ChatHandler {
 
         sendPartyMessage(party, partyMessage, user.getIgnoredBy());
 
-        ComponentLike spyMessage = Utility.parseMiniMessage(Config.PARTY_SPY, Placeholders);
+        chatLogHandler.addChatLog(uuid,
+                serverConnection.getServer().getServerInfo().getName(),
+                PlainTextComponentSerializer.plainText().serialize(partyMessage),
+                ChatLogType.PARTY,
+                String.valueOf(party.getPartyId()),
+                null,
+                partyMessage,
+                false
+        );
+
+        ComponentLike spyMessage = Utility.parseMiniMessage(Config.PARTY_SPY, placeholders);
         for (Player pl : serverConnection.getServer().getPlayersConnected()) {
             if (pl.hasPermission(Config.SPYPERMISSION) && !party.getPartyUsersUuid().contains(pl.getUniqueId())) {
                 pl.sendMessage(spyMessage);
@@ -171,6 +198,17 @@ public class ChatHandler {
                 .stream()
                 .filter(target -> target.hasPermission("command.chat.globaladminchat"))
                 .forEach(target -> target.sendMessage(component));
+
+        chatLogHandler.addChatLog(
+                new UUID(0, 0), //No origin uuid for GAC
+                "GAC", //No server for GAC
+                PlainTextComponentSerializer.plainText().serialize(component),
+                ChatLogType.GAC,
+                null,
+                null,
+                component,
+                false
+        );
     }
 
     public void globalAdminChat(CommandSource commandSource, String message) {
@@ -182,13 +220,17 @@ public class ChatHandler {
                 return;
             }
             senderName = user.getDisplayName();
-            serverName = sender.getCurrentServer().isPresent() ? sender.getCurrentServer().get().getServerInfo().getName() : "Altitude";
+            serverName = sender.getCurrentServer().isPresent() ? sender.getCurrentServer()
+                    .get()
+                    .getServerInfo()
+                    .getName() : "Altitude";
         }
 
         TagResolver Placeholders = TagResolver.resolver(
                 Placeholder.component("message", parseMessageContent(commandSource, message)),
                 Placeholder.component("sender", senderName),
-                Placeholder.unparsed("server", serverName));
+                Placeholder.unparsed("server", serverName)
+        );
 
         ComponentLike component = Utility.parseMiniMessage(Config.GACFORMAT, Placeholders);
 
@@ -210,7 +252,8 @@ public class ChatHandler {
         if (optionalPlayer.isEmpty()) {
             targetUUID = ServerHandler.getPlayerUUID(recipient);
             if (targetUUID == null) {
-                commandSource.sendMessage(Utility.parseMiniMessage("<red>A player with this name hasn't logged in recently.")); // TOOD load from config
+                commandSource.sendMessage(Utility.parseMiniMessage(
+                        "<red>A player with this name hasn't logged in recently.")); // TOOD load from config
                 return;
             }
         } else {
@@ -274,7 +317,9 @@ public class ChatHandler {
                     Placeholder.component("sender", chatUser.getDisplayName()),
                     Placeholder.component("message", Utility.parseMiniMessage(mail.getMessage())),
                     Placeholder.unparsed("date", date.toString()),
-                    Placeholder.unparsed("time_ago", getTimeAgo(Duration.between(date.toInstant(), new Date().toInstant())))
+                    Placeholder.unparsed("time_ago",
+                            getTimeAgo(Duration.between(date.toInstant(), new Date().toInstant()))
+                    )
             );
             ComponentLike mailMessage = Utility.parseMiniMessage(Config.mailBody, Placeholders);
             component = component.append(Component.newline()).append(mailMessage);

web-api/build.gradle.kts

@@ -0,0 +1,66 @@
+plugins {
+    java
+    id("org.openapi.generator") version "7.12.0"
+}
+
+group = "com.alttd.chat"
+version = "2.0.0-SNAPSHOT"
+
+dependencies {
+    implementation("io.swagger.core.v3:swagger-annotations:2.2.28")
+
+    implementation("com.squareup.okhttp3:okhttp:4.12.0")
+    implementation("com.squareup.okhttp3:logging-interceptor:4.12.0")
+
+    implementation("com.google.code.gson:gson:2.12.1")
+    implementation("io.gsonfire:gson-fire:1.9.0")
+
+    implementation("javax.annotation:javax.annotation-api:1.3.2")
+    implementation("jakarta.annotation:jakarta.annotation-api:2.1.1")
+}
+
+sourceSets {
+    main {
+        java {
+            srcDir("${projectDir}/build/generated-sources/client/src/main/java")
+        }
+    }
+}
+
+tasks.named<org.openapitools.generator.gradle.plugin.tasks.GenerateTask>("openApiGenerate") {
+    generatorName.set("java")
+    inputSpec.set("${projectDir}/src/main/resources/chat-api.yml")
+    configFile.set("${projectDir}/src/main/resources/config_backend.json")
+    outputDir.set("${projectDir}/build/generated-sources/client")
+
+    apiPackage.set("com.alttd.altitudeweb.api")
+    modelPackage.set("com.alttd.altitudeweb.model")
+
+    modelNameSuffix.set("Dto")
+
+    additionalProperties.set(
+        mapOf(
+            "dateLibrary" to "java8",
+            "library" to "okhttp-gson"
+        )
+    )
+
+    generateApiTests.set(false)
+    generateApiDocumentation.set(false)
+    generateModelTests.set(false)
+    generateModelDocumentation.set(false)
+
+    generateAliasAsModel.set(true)
+}
+
+sourceSets {
+    main {
+        java {
+            srcDir(layout.buildDirectory.dir("generated/openapi/src/main/java"))
+        }
+    }
+}
+
+tasks.compileJava {
+    dependsOn("openApiGenerate")
+}

web-api/src/main/resources/chat-api.yml

@@ -0,0 +1,144 @@
+openapi: 3.0.3
+
+info:
+  title: Minecraft Network API
+  version: 1.0.0
+
+servers:
+  - url: http://localhost:8080/api
+
+tags:
+  - name: chat
+    description: Data for displaying Chat messages to clients
+
+paths:
+  /chat/send/chat/message:
+    post:
+      tags:
+        - chat
+      summary: Sends one or more chat messages
+      operationId: sendChatMessages
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: array
+              items:
+                $ref: "#/components/schemas/ChatMessage"
+      responses:
+        "202":
+          description: Accepted
+
+  /chat/send/servers/state:
+    post:
+      tags:
+        - chat
+      summary: Update server states
+      operationId: updateServerStates
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/ServerState"
+      responses:
+        "202":
+          description: Accepted
+
+components:
+  schemas:
+    User:
+      type: object
+      required:
+        - uuid
+        - name
+        - styledName
+      # TODO [Stijn] [2026-07-19]: Add who they ignore and who they are ignored by
+
+      properties:
+        uuid:
+          type: string
+          format: uuid
+        name:
+          type: string
+        styledName:
+          type: string
+
+    ChatMessage:
+      type: object
+      required:
+        - uuid
+        - message
+        - server
+        - type
+        - timestamp
+        - blocked
+      properties:
+        uuid:
+          type: string
+          format: uuid
+        message:
+          type: string
+        server:
+          type: string
+        type:
+          type: string
+          enum:
+            - PUBLIC
+            - GLOBAL
+            - PARTY
+            - GAC
+            - MSG
+            - CUSTOM
+        channel:
+          type: string
+          maxLength: 36
+        receiver:
+          type: string
+          maxLength: 36
+        timestamp:
+          type: string
+          format: date-time
+        blocked:
+          type: boolean
+
+    PrivateMessage:
+      type: object
+      required:
+        - sender
+        - receiver
+        - message
+        - senderServer
+        - receiverServer
+      properties:
+        sender:
+          type: string
+          format: uuid
+        receiver:
+          type: string
+          format: uuid
+        message:
+          type: string
+        senderServer:
+          type: string
+        receiverServer:
+          type: string
+
+    Server:
+      type: object
+      properties:
+        name:
+          type: string
+        players:
+          type: array
+          items:
+            $ref: "#/components/schemas/User"
+
+    ServerState:
+      type: object
+      properties:
+        servers:
+          type: array
+          items:
+            $ref: "#/components/schemas/Server"

web-api/src/main/resources/config_backend.json

@@ -0,0 +1,22 @@
+{
+  "library": "okhttp-gson",
+  "hideGenerationTimestamp": true,
+  "modelPackage": "com.alttd.altitudeweb.model",
+  "apiPackage": "com.alttd.altitudeweb.api",
+  "invokerPackage": "com.alttd.altitudeweb.invoker",
+  "serializableModel": true,
+  "openApiNullable": false,
+  "useTags": true,
+  "generateApis": true,
+  "generateApiTests": false,
+  "generateApiDocumentation": false,
+  "generateModels": true,
+  "generateModelTests": false,
+  "generateSupportingFiles": true,
+  "modelNameSuffix": "Dto",
+  "generateTests": false,
+  "dateLibrary": "java8",
+  "enumUnknownDefaultCase": true,
+  "disallowAdditionalPropertiesIfNotPresent": false,
+  "useJakartaEe": true
+}