Code improvements

- Added PreSendOnLoginEvent
- ProxyLoginEvent is record now
- Improve send to server on login feature

proxy/src/main/java/com/glyart/authmevelocity/proxy/AuthMeVelocityPlugin.java

@@ -9,6 +9,8 @@ import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
 import com.velocitypowered.api.plugin.annotation.DataDirectory;
 import com.velocitypowered.api.proxy.ProxyServer;
 import com.velocitypowered.api.proxy.messages.MinecraftChannelIdentifier;
+
+import org.jetbrains.annotations.NotNull;
 import org.slf4j.Logger;
 
 import java.nio.file.Path;
@@ -36,7 +38,7 @@ public class AuthMeVelocityPlugin {
     @Subscribe
     public void onProxyInitialize(ProxyInitializeEvent event) {
         AuthMeConfig.loadConfig(pluginDirectory, logger);
-        var config = AuthMeConfig.getConfig();
+        @NotNull var config = AuthMeConfig.getConfig();
 
         proxy.getChannelRegistrar().register(
             MinecraftChannelIdentifier.create("authmevelocity", "main"));

proxy/src/main/java/com/glyart/authmevelocity/proxy/event/PreSendOnLoginEvent.java

@@ -0,0 +1,44 @@
+package com.glyart.authmevelocity.proxy.event;
+
+import java.util.Objects;
+
+import com.velocitypowered.api.event.ResultedEvent;
+import com.velocitypowered.api.event.ResultedEvent.GenericResult;
+import com.velocitypowered.api.proxy.Player;
+import com.velocitypowered.api.proxy.server.RegisteredServer;
+
+public class PreSendOnLoginEvent implements ResultedEvent<GenericResult> {
+
+    private GenericResult result = GenericResult.allowed();
+    private final Player player;
+    private final RegisteredServer actualserver;
+    private final RegisteredServer serverToSend;
+
+    public PreSendOnLoginEvent(Player player, RegisteredServer actualServer, RegisteredServer serverToSend){
+        this.player = player;
+        this.actualserver = actualServer;
+        this.serverToSend = serverToSend;
+    }
+
+    public Player getPlayer(){
+        return this.player;
+    }
+
+    public RegisteredServer getActualServer(){
+        return this.actualserver;
+    }
+
+    public RegisteredServer getSendServer(){
+        return this.serverToSend;
+    }
+    
+    @Override
+    public GenericResult getResult() {
+        return this.result;
+    }
+
+    @Override
+    public void setResult(GenericResult newresult) {
+        this.result = Objects.requireNonNull(newresult);
+    }
+}

proxy/src/main/java/com/glyart/authmevelocity/proxy/event/ProxyLoginEvent.java

@@ -6,29 +6,4 @@ import com.velocitypowered.api.proxy.server.RegisteredServer;
 /**
  * Event executed in case the player is successfully logged in
  */
-public class ProxyLoginEvent {
+public record ProxyLoginEvent(Player player, RegisteredServer server) {}
-
-    private final Player player;
-    private final RegisteredServer server;
-
-    public ProxyLoginEvent(Player player, RegisteredServer server){
-        this.player = player;
-        this.server = server;
-    }
-
-    /**
-     * Get the player who has logged in
-     * @return the login player
-     */
-    public Player getPlayer(){
-        return this.player;
-    }
-
-    /**
-     * Obtain the server to which the user is logged in.
-     * @return the login server
-     */
-    public RegisteredServer getServer(){
-        return this.server;
-    }
-}

proxy/src/main/java/com/glyart/authmevelocity/proxy/listener/ProxyListener.java

@@ -2,6 +2,7 @@ package com.glyart.authmevelocity.proxy.listener;
 
 import com.glyart.authmevelocity.proxy.AuthmeVelocityAPI;
 import com.glyart.authmevelocity.proxy.config.AuthMeConfig;
+import com.glyart.authmevelocity.proxy.event.PreSendOnLoginEvent;
 import com.glyart.authmevelocity.proxy.event.ProxyLoginEvent;
 import com.google.common.io.ByteArrayDataInput;
 import com.velocitypowered.api.event.EventTask;
@@ -17,13 +18,13 @@ import com.velocitypowered.api.proxy.ProxyServer;
 import com.velocitypowered.api.proxy.ServerConnection;
 import com.velocitypowered.api.proxy.server.RegisteredServer;
 
+import org.jetbrains.annotations.NotNull;
 import org.slf4j.Logger;
 
 import java.util.List;
 import java.util.Optional;
 import java.util.Random;
 import java.util.UUID;
-import java.util.concurrent.ExecutionException;
 
 public class ProxyListener {
     private final ProxyServer proxy;
@@ -31,7 +32,7 @@ public class ProxyListener {
     private final Random rm;
     private AuthMeConfig.Config config;
 
-    public ProxyListener(ProxyServer proxy, Logger logger, AuthMeConfig.Config config) {
+    public ProxyListener(@NotNull ProxyServer proxy, @NotNull Logger logger, @NotNull AuthMeConfig.Config config) {
         this.proxy = proxy;
         this.logger = logger;
         this.rm = new Random();
@@ -49,31 +50,34 @@ public class ProxyListener {
 
         String user = input.readUTF();
         Optional<Player> optionalPlayer = proxy.getPlayer(UUID.fromString(user));
-        if (!optionalPlayer.isPresent()) return;
+        if (optionalPlayer.isEmpty()) return;
 
         Player loggedPlayer = optionalPlayer.get();
         if (AuthmeVelocityAPI.addPlayer(loggedPlayer)){
-            RegisteredServer loginServer = loggedPlayer.getCurrentServer().orElseThrow().getServer();
+            createServerConnectionRequest(loggedPlayer, config, proxy, logger);
+        }
+    }
+
+    private void createServerConnectionRequest(Player loggedPlayer, AuthMeConfig.Config config, ProxyServer proxy, Logger logger){
+        final RegisteredServer loginServer = loggedPlayer.getCurrentServer().orElseThrow().getServer();
         proxy.getEventManager().fireAndForget(new ProxyLoginEvent(loggedPlayer, loginServer));
         if(config.getToServerOptions().sendToServer()){
-                List<String> serverList = config.getToServerOptions().getTeleportServers();
+            final List<String> serverList = config.getToServerOptions().getTeleportServers();
-                String randomServer = serverList.get(rm.nextInt(serverList.size()));
+            final String randomServer = serverList.get(rm.nextInt(serverList.size()));
             Optional<RegisteredServer> optionalServer = proxy.getServer(randomServer);
-                optionalServer.ifPresentOrElse(serverToSend -> {
+            optionalServer.ifPresentOrElse(serverToSend -> 
-                    try{
+                proxy.getEventManager().fire(new PreSendOnLoginEvent(loggedPlayer, loginServer, serverToSend)).thenAccept(preSendEvent -> {
-                        if(!loggedPlayer.createConnectionRequest(serverToSend).connect().get().isSuccessful()){
+                    if(preSendEvent.getResult().isAllowed()){
+                        loggedPlayer.createConnectionRequest(serverToSend).connect().thenAccept(result -> {
+                            if(!result.isSuccessful()) {
                                 logger.info("Unable to connect the player {} to the server {}",
                                     loggedPlayer.getUsername(),
                                     serverToSend.getServerInfo().getName());
                             }
-                    } catch (InterruptedException | ExecutionException exception){
+                        });
-                        logger.info("Unable to connect the player {} to the server {}. Error: {}",
-                            loggedPlayer.getUsername(),
-                            serverToSend.getServerInfo().getName(),
-                            exception);
-                    }
-                }, () -> logger.info("The server {} does not exist", randomServer));
                     }
+                })
+            , () -> logger.info("The server {} does not exist", randomServer));
         }
     }