Merge branch 'dev' into 'master'

2.2.0

See merge request ajg0702/ajqueue!33

api/src/main/java/us/ajg0702/queue/api/QueueManager.java

@@ -117,6 +117,13 @@ public interface QueueManager {
      */
     ImmutableList<QueuePlayer> findPlayerInQueues(AdaptedPlayer p);
 
+    /**
+     * Finds QueuePlayers that have this username
+     * @param name The username to look up
+     * @return A list of QueuePlayers that have this username
+     */
+    ImmutableList<QueuePlayer> findPlayerInQueuesByName(String name);
+
     /**
      * Gets all of the queues the player is currently queued for
      * @param p The player

api/src/main/java/us/ajg0702/queue/api/premium/Logic.java

@@ -1,8 +1,10 @@
 package us.ajg0702.queue.api.premium;
 
+import us.ajg0702.queue.api.AjQueueAPI;
 import us.ajg0702.queue.api.players.AdaptedPlayer;
 import us.ajg0702.queue.api.players.QueuePlayer;
 import us.ajg0702.queue.api.queues.QueueServer;
+import us.ajg0702.utils.common.Config;
 
 @SuppressWarnings({"SameReturnValue", "unused"})
 
@@ -32,4 +34,34 @@ public interface Logic {
      * @return the permission getter
      */
     PermissionGetter getPermissionGetter();
+
+    static int getUnJoinablePriorities(QueueServer server, AdaptedPlayer player) {
+        Config config = AjQueueAPI.getInstance().getConfig();
+        int highest = 0;
+
+        int whitelitedPriority = config.getInt("give-whitelisted-players-priority");
+        int bypassPausedPriotity = config.getInt("give-whitelisted-players-priority");
+        int fulljoinPriority = config.getInt("give-whitelisted-players-priority");
+
+        if(whitelitedPriority > 0) {
+            if(server.isWhitelisted() && server.getWhitelistedPlayers().contains(player.getUniqueId())) {
+                highest = whitelitedPriority;
+            }
+        }
+
+        if(bypassPausedPriotity > 0) {
+            if(server.isPaused() && (player.hasPermission("ajqueue.bypasspaused"))) {
+                highest = Math.max(highest, bypassPausedPriotity);
+            }
+        }
+
+        if(fulljoinPriority > 0) {
+            if(server.isFull() && server.canJoinFull(player)) {
+                highest = Math.max(highest, fulljoinPriority);
+            }
+        }
+
+
+        return highest;
+    }
 }

api/src/main/java/us/ajg0702/queue/api/premium/PermissionGetter.java

@@ -13,4 +13,6 @@ public interface PermissionGetter {
     int getServerPriotity(String server, AdaptedPlayer player);
 
     boolean hasContextBypass(AdaptedPlayer player, String server);
+
+    boolean hasUniqueFullBypass(AdaptedPlayer player, String server);
 }

api/src/main/java/us/ajg0702/queue/api/queues/QueueServer.java

@@ -192,6 +192,12 @@ public interface QueueServer {
      */
     boolean isGroup();
 
+    /**
+     * Finds the player in this queue and returns the representative QueuePlayer
+     * @return The QueuePlayer representing the player, null if not found
+     */
+    QueuePlayer findPlayer(String player);
+
     /**
      * Finds the player in this queue and returns the representative QueuePlayer
      * @return The QueuePlayer representing the player, null if not found

build.gradle.kts

@@ -12,7 +12,7 @@ repositories {
 }
 
 allprojects {
-    version = "2.1.1"
+    version = "2.2.0"
     group = "us.ajg0702"
 
     plugins.apply("java")

common/src/main/java/us/ajg0702/queue/commands/commands/manage/Kick.java

@@ -0,0 +1,95 @@
+package us.ajg0702.queue.commands.commands.manage;
+
+import com.google.common.collect.ImmutableList;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.spongepowered.configurate.ConfigurateException;
+import us.ajg0702.queue.api.commands.ICommandSender;
+import us.ajg0702.queue.api.players.QueuePlayer;
+import us.ajg0702.queue.api.queues.QueueServer;
+import us.ajg0702.queue.commands.SubCommand;
+import us.ajg0702.queue.common.QueueMain;
+import us.ajg0702.utils.common.Messages;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Kick extends SubCommand {
+
+    final QueueMain main;
+    public Kick(QueueMain main) {
+        this.main = main;
+    }
+
+    @Override
+    public String getName() {
+        return "kick";
+    }
+
+    @Override
+    public ImmutableList<String> getAliases() {
+        return ImmutableList.of();
+    }
+
+    @Override
+    public String getPermission() {
+        return "ajqueue.manage.kick";
+    }
+
+    @Override
+    public Messages getMessages() {
+        return main.getMessages();
+    }
+
+    @Override
+    public void execute(ICommandSender sender, String[] args) {
+        if(!checkPermission(sender)) return;
+
+        if(args.length < 1) {
+            sender.sendMessage(getMessages().getComponent("commands.kick.usage"));
+            return;
+        }
+
+        List<QueuePlayer> kickPlayers;
+
+        if(args.length == 1) {
+            kickPlayers = main.getQueueManager().findPlayerInQueuesByName(args[0]);
+        } else {
+            QueueServer queue = main.getQueueManager().findServer(args[1]);
+            if(queue == null) {
+                sender.sendMessage(getMessages().getComponent("commands.kick.unknown-server", "QUEUE:"+args[1]));
+                return;
+            }
+            kickPlayers = Collections.singletonList(queue.findPlayer(args[0]));
+        }
+
+        if(kickPlayers.size() == 0) {
+            sender.sendMessage(getMessages().getComponent("commands.kick.no-player", "PLAYER:"+args[0]));
+            return;
+        }
+
+        for(QueuePlayer player : kickPlayers) {
+            player.getQueueServer().removePlayer(player);
+        }
+
+        sender.sendMessage(getMessages().getComponent(
+                "commands.kick.success",
+                "PLAYER:"+args[0],
+                "NUM:"+kickPlayers.size(),
+                "s:"+ (kickPlayers.size() == 1 ? "" : "s")
+        ));
+    }
+
+    @Override
+    public List<String> autoComplete(ICommandSender sender, String[] args) {
+        if(args.length == 1) {
+            return main.getPlatformMethods().getPlayerNames(false);
+        }
+        if(args.length == 2) {
+            return main.getQueueManager().getServerNames();
+        }
+        return new ArrayList<>();
+    }
+}
+

common/src/main/java/us/ajg0702/queue/commands/commands/manage/ManageCommand.java

@@ -31,6 +31,7 @@ public class ManageCommand extends BaseCommand {
         addSubCommand(new PermissionList(main));
         addSubCommand(new Whitelist(main));
         addSubCommand(new Update(main));
+        addSubCommand(new Kick(main));
     }
 
 

common/src/main/java/us/ajg0702/queue/common/QueueMain.java

@@ -210,6 +210,10 @@ public class QueueMain extends AjQueueAPI {
         d.put("commands.leave-queue", "&aYou left the queue for {SERVER}!");
         d.put("commands.reload", "&aConfig and messages reloaded successfully!");
         d.put("commands.joinqueue.usage", "&cUsage: /joinqueue <server>");
+        d.put("commands.kick.usage", "<red>Usage: /ajqueue kick <player> [queue]");
+        d.put("commands.kick.no-player", "&cCould not find {PLAYER}! Make sure they are in a queue!");
+        d.put("commands.kick.unknown-server", "&cCould not find queue {QUEUE}. Make sure you spelled it correctly!");
+        d.put("commands.kick.success", "<green>Kicked <white>{PLAYER} <green>from {NUM} queue{s}!");
 
         d.put("noperm", "&cYou do not have permission to do this!");
 

common/src/main/java/us/ajg0702/queue/common/QueueManagerImpl.java

@@ -6,6 +6,7 @@ import net.kyori.adventure.title.Title;
 import us.ajg0702.queue.api.QueueManager;
 import us.ajg0702.queue.api.players.AdaptedPlayer;
 import us.ajg0702.queue.api.players.QueuePlayer;
+import us.ajg0702.queue.api.premium.Logic;
 import us.ajg0702.queue.api.queues.QueueServer;
 import us.ajg0702.queue.api.server.AdaptedServer;
 import us.ajg0702.queue.common.players.QueuePlayerImpl;
@@ -151,6 +152,7 @@ public class QueueManagerImpl implements QueueManager {
         } else {
             int priority = player.hasPermission("ajqueue.priority") ||
                     player.hasPermission("ajqueue.serverpriority."+server.getName()) ? 1 : 0;
+            priority = Math.max(priority, Logic.getUnJoinablePriorities(server, player) > 0 ? 1 : 0);
             int maxOfflineTime = player.hasPermission("ajqueue.stayqueued") ? 60 : 0;
             queuePlayer = new QueuePlayerImpl(player, server, priority, maxOfflineTime);
             if(
@@ -407,20 +409,22 @@ public class QueueManagerImpl implements QueueManager {
 
     @Override
     public void sendQueueEvents() {
-        List<String> svs = main.getConfig().getStringList("queue-servers");
+        if(main.getConfig().getBoolean("force-queue-server-target")) {
-        for(String s : svs) {
+            List<String> svs = main.getConfig().getStringList("queue-servers");
-            if(!s.contains(":")) continue;
+            for(String s : svs) {
-            String[] parts = s.split(":");
+                if(!s.contains(":")) continue;
-            String fromName = parts[0];
+                String[] parts = s.split(":");
-            String toName = parts[1];
+                String fromName = parts[0];
-            AdaptedServer from = main.getPlatformMethods().getServer(fromName);
+                String toName = parts[1];
-            QueueServer to = findServer(toName);
+                AdaptedServer from = main.getPlatformMethods().getServer(fromName);
-            if(from == null || to == null) continue;
+                QueueServer to = findServer(toName);
-            from.getPlayers().forEach(player -> {
+                if(from == null || to == null) continue;
-                if(!getPlayerQueues(player).contains(to)) {
+                from.getPlayers().forEach(player -> {
-                    addToQueue(player, to);
+                    if(!getPlayerQueues(player).contains(to)) {
-                }
+                        addToQueue(player, to);
-            });
+                    }
+                });
+            }
         }
         for (QueueServer s : servers) {
             for (QueuePlayer queuePlayer : s.getQueue()) {
@@ -523,7 +527,6 @@ public class QueueManagerImpl implements QueueManager {
         }
 
         for(QueueServer server : sendingServers) {
-            Debugger.debug("Sending players for "+server.getName());
             for(QueuePlayer queuePlayer : server.getQueue()) {
                 if(queuePlayer.getPlayer() != null) continue;
                 if(main.getLogic().playerDisconnectedTooLong(queuePlayer)) {
@@ -635,6 +638,18 @@ public class QueueManagerImpl implements QueueManager {
         return ImmutableList.copyOf(srs);
     }
 
+    @Override
+    public ImmutableList<QueuePlayer> findPlayerInQueuesByName(String name) {
+        List<QueuePlayer> srs = new ArrayList<>();
+        for(QueueServer s : servers) {
+            QueuePlayer player = s.findPlayer(name);
+            if(player != null) {
+                srs.add(player);
+            }
+        }
+        return ImmutableList.copyOf(srs);
+    }
+
     @Override
     public ImmutableList<QueueServer> getPlayerQueues(AdaptedPlayer p) {
         List<QueueServer> srs = new ArrayList<>();

common/src/main/java/us/ajg0702/queue/common/queues/QueueServerImpl.java

@@ -1,7 +1,6 @@
 package us.ajg0702.queue.common.queues;
 
 import com.google.common.collect.ImmutableList;
-import jdk.nashorn.internal.runtime.Debug;
 import us.ajg0702.queue.api.players.AdaptedPlayer;
 import us.ajg0702.queue.api.players.QueuePlayer;
 import us.ajg0702.queue.api.queues.Balancer;
@@ -13,7 +12,6 @@ import us.ajg0702.queue.common.players.QueuePlayerImpl;
 import us.ajg0702.queue.common.queues.balancers.DefaultBalancer;
 import us.ajg0702.queue.common.queues.balancers.MinigameBalancer;
 import us.ajg0702.queue.common.utils.Debugger;
-import us.ajg0702.utils.common.GenUtils;
 import us.ajg0702.utils.common.Messages;
 
 import java.util.*;
@@ -43,7 +41,7 @@ public class QueueServerImpl implements QueueServer {
             String balancerType = type.substring(colon+1);
 
             if(groupName.equals(name)) {
-                boolean valid = true;
+                //noinspection SwitchStatementWithTooFewBranches
                 switch(balancerType.toLowerCase(Locale.ROOT)) {
                     case "minigame":
                         balancer = new MinigameBalancer(this, main);
@@ -404,6 +402,15 @@ public class QueueServerImpl implements QueueServer {
         return servers.size() > 1;
     }
 
+    @Override
+    public QueuePlayer findPlayer(String player) {
+        for(QueuePlayer queuePlayer : queue) {
+            if(queuePlayer.getName().equalsIgnoreCase(player)) {
+                return queuePlayer;
+            }
+        }
+        return null;
+    }
     @Override
     public QueuePlayer findPlayer(AdaptedPlayer player) {
         return findPlayer(player.getUniqueId());
@@ -451,7 +458,9 @@ public class QueueServerImpl implements QueueServer {
                 player.hasPermission("ajqueue.joinfull") ||
                 player.hasPermission("ajqueue.joinfullserver."+name) ||
                 player.hasPermission("ajqueue.joinfullandbypassserver."+name) ||
-                player.hasPermission("ajqueue.joinfullandbypass");
+                player.hasPermission("ajqueue.joinfullandbypass") ||
+                (main.isPremium() && main.getLogic().getPermissionGetter().hasUniqueFullBypass(player, name))
+                ;
     }
 
     @Override

common/src/main/resources/config.yml

@@ -1,5 +1,5 @@
 # Dont touch this number please
-config-version: 30
+config-version: 31
 
 
 # This is the main config for ajQueue.
@@ -278,6 +278,29 @@ slash-servers: []
 balancer-types:
   - "bedwars:minigame"
 
+# What priority should we give whitelisted players priority when the server is whitelisted?
+# This will have no effect if the server isnt whitelisted
+# If you set to 0, this will be disabled
+# If you have the free version, set it to 1 to enable
+give-whitelisted-players-priority: 0
 
-# Should we print some extra stuff to the console that might help diagnose some issues?
+# What priority should we give players that are able to bypass paused priority when the server is paused?
+# This will have no effect if the server isnt paused
+# If you set to 0, this will be disabled
+# If you have the free version, set it to 1 to enable
+give-pausedbypass-players-priority: 0
+
+# What priority should we give players that are able to bypass full servers priority when the server is full?
+# This will have no effect if the server isnt full
+# If you set to 0, this will be disabled
+# If you have the free version, set it to 1 to enable
+give-fulljoin-players-priority: 0
+
+
+# Should we force players to be queued every few seconds for queue-servers?
+# This will check every few seconds, and if a player in a queue-server is
+#  not in the queue for the target server, it will add them.
+force-queue-server-target: true
+
+# Should we print some extra stuff to the console that might help aj diagnose some issues?
 debug: false

premium/src/main/java/us/ajg0702/queue/logic/PremiumLogic.java

@@ -41,7 +41,8 @@ public class PremiumLogic implements Logic {
                 player.hasPermission("ajqueue.serverbypass."+server.getName()) ||
                 player.hasPermission("ajqueue.joinfullandbypassserver."+server.getName()) ||
                 player.hasPermission("ajqueue.joinfullandbypass") ||
-                permissionGetter.hasContextBypass(player, server.getName())
+                permissionGetter.hasContextBypass(player, server.getName()) ||
+                (main.isPremium() && main.getLogic().getPermissionGetter().hasUniqueFullBypass(player, server.getName()))
         ) {
             if(debug) {
                 logger.info("[priority] "+player.getName()+" bypass");
@@ -60,6 +61,7 @@ public class PremiumLogic implements Logic {
         }
 
         int highestPriority = Math.max(priority, serverPriority);
+        highestPriority = Math.max(highestPriority, Logic.getUnJoinablePriorities(server, player));
 
         QueuePlayer queuePlayer = new QueuePlayerImpl(player, server, highestPriority, maxOfflineTime);
 
@@ -81,15 +83,16 @@ public class PremiumLogic implements Logic {
 
         for(int i = 0; i < list.size(); i++) {
             QueuePlayer pl = list.get(i);
-            if(pl.getPriority() < highestPriority) {
+            if (pl.getPriority() < highestPriority) {
-                if(debug) {
+                if (debug) {
-                    logger.info("[priority] "+player.getName()+"  Adding to: "+i);
+                    logger.info("[priority] " + player.getName() + "  Adding to: " + i);
                 }
                 server.addPlayer(queuePlayer, i);
                 return queuePlayer;
             }
         }
 
+
         if(debug) {
             logger.info("[priority] "+player.getName()+"  Cant go infront of anyone" );
         }

premium/src/main/java/us/ajg0702/queue/logic/permissions/PermissionGetterImpl.java

@@ -69,6 +69,18 @@ public class PermissionGetterImpl implements PermissionGetter {
         return perms.contains("ajqueue.serverbypass."+server);
     }
 
+    @Override
+    public boolean hasUniqueFullBypass(AdaptedPlayer player, String server) {
+        if(player.hasPermission("ajqueue.joinfullandbypassserver."+server)) return true;
+
+        if(getSelected() == null) {
+            return false;
+        }
+        List<String> perms = getSelected().getPermissions(player);
+        perms.removeIf(s -> !s.startsWith("ajqueue.joinfullandbypassserver."+server));
+        return perms.size() > 0;
+    }
+
     private int getHighestPermission(AdaptedPlayer player, String prefix) {
         if(getSelected() == null) {
             return -1;