Java 类org.bukkit.event.player.PlayerLoginEvent 实例源码

@EventHandler
public void onLogin(PlayerLoginEvent event) {
    QueuedJoin queuedJoin = getQueuedUserProfile(event.getPlayer());
    if (queuedJoin == null) {
        event.setResult(PlayerLoginEvent.Result.KICK_OTHER);
        event.setKickMessage(ChatColor.RED + "Unable to load user profile. Please try again.");
        return;
    }

    PlayerContext playerContext = new PlayerContext(event.getPlayer(), queuedJoin.getUserProfile());
    TGM.get().getPlayerManager().addPlayer(playerContext);

    for (LoginService loginService : loginServices) {
        loginService.login(playerContext);
    }

    queuedJoins.remove(queuedJoin);
}

@EventHandler(priority = EventPriority.HIGHEST)
public void onPlayerLogin(PlayerLoginEvent event)
{
    if (!Capatchafy.forced && !Capatchafy.configs.config.getBoolean("always-on") && !Capatchafy.enabled)
    {
        throttleConnections();
    }
    if (!Capatchafy.enabled) return;
    String ip = event.getAddress().toString().replaceAll("/", "");
    if (!Capatchafy.configs.isAuthorized(ip))
    {
        event.disallow(PlayerLoginEvent.Result.KICK_OTHER, ChatColor.RED + "" + ChatColor.BOLD + "Yikes, we're under attack! Please solve the capatcha.\n" +
                ChatColor.WHITE + "Please go to " + ChatColor.GOLD + url + ChatColor.WHITE + " in your web browser and solve the capatcha.\n" +
                "Once solved successfully, you will be able to join.");
        return;
    }
    if (Capatchafy.securityLevel == 3)
    {
        Capatchafy.configs.setAuthorized(ip, false);
    }
}

@EventHandler(priority = EventPriority.LOWEST)
public void onPlayerLogin(UserLoginEvent event) {
    TeamManager teamManager = teamManagerProvider.get();

    Entrant participation = teamManager.getEntrant(event.getUser());
    if(participation == null) return;

    final int playerCount = (int) onlinePlayers.all()
                                               .stream()
                                               .filter(player -> !player.equals(event.getPlayer()) &&
                                                                 participation.members().contains(userStore.playerId(player)))
                                               .count();

    int maxPlayers = tournament.max_players_per_match();
    if(playerCount >= maxPlayers) {
        event.disallow(PlayerLoginEvent.Result.KICK_WHITELIST, new Component(new TranslatableComponent("tourney.kick.maxPlayers", String.valueOf(maxPlayers)), ChatColor.RED));
    } else {
        if(event.getResult().equals(PlayerLoginEvent.Result.KICK_WHITELIST)) {
            event.allow(); // explicitly allow players on teams but not whitelist
        }
    }
}

@EventHandler
public void playerLogin(PlayerLoginEvent event){
    VPPlayer player = preLoad(event.getPlayer());
    if(player == null){
        ErrorLogger.addError("Couldn't preload " + event.getPlayer());
        event.setResult(Result.KICK_OTHER);
        return;
    }
    if(player.isOnline()){
        event.setResult(Result.KICK_OTHER);
        //player.setOffline();
        return;
    }
    VanillaPlusCore.getChannelManager().init(player);
    VPPLoginEvent e = new VPPLoginEvent(player);
    e.setResult(Result.ALLOWED);
    Bukkit.getServer().getPluginManager().callEvent(e);
    event.setResult(e.getResult());
}

@EventHandler
public void onPlayerLogin(PlayerLoginEvent event)
{
    //Don't force if player is hided moderator
    Bukkit.getScheduler().runTaskLater(pluginAPI, () -> {
        if(!pluginAPI.getAPI().getJoinManager().getModeratorsExpected().contains(event.getPlayer().getUniqueId()))
        {
            try{
                sendPlayerToAll(event.getPlayer());
                sendAllToPlayer(event.getPlayer());
            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }, 5L);
}

@EventHandler
public void onLogin(PlayerLoginEvent event)
{
    if (!allowJoin)
    {
        event.disallow(PlayerLoginEvent.Result.KICK_OTHER, ChatColor.RED + denyJoinReason);
        event.setResult(PlayerLoginEvent.Result.KICK_WHITELIST);
        event.setKickMessage(ChatColor.RED + denyJoinReason);

        return;
    }

    if (joinPermission != null && !api.getPermissionsManager().hasPermission(event.getPlayer(), joinPermission))
    {
        event.disallow(PlayerLoginEvent.Result.KICK_WHITELIST, "Vous n'avez pas la permission de rejoindre ce serveur.");
    }

    if (!ipWhiteList.contains(event.getRealAddress().getHostAddress()))
    {
        event.setResult(PlayerLoginEvent.Result.KICK_WHITELIST);
        event.setKickMessage(ChatColor.RED + "Erreur de connexion vers le serveur... Merci de bien vouloir ré-essayer plus tard.");
        Bukkit.getLogger().log(Level.WARNING, "An user tried to connect from IP " + event.getRealAddress().getHostAddress());
    }
}

@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerLogin(PlayerLoginEvent e)
{
    if (e.getResult() == PlayerLoginEvent.Result.ALLOWED)
    {
        User user = MWAPI.getOfflineUserHandler().findById(e.getPlayer().getUniqueId());

        if (user == null)
        {
            user = new BasicUser(e.getPlayer().getUniqueId());

            MWAPI.getOfflineUserHandler().insert(user);
        }

        ((BasicUserHandler) MWAPI.getUserHandler()).add(user);
    }
}

@Override
public void setup(TerminableConsumer consumer) {
    Events.subscribe(PlayerLoginEvent.class)
            .handler(e -> attachments.put(e.getPlayer().getUniqueId(), e.getPlayer().addAttachment(this)))
            .bindWith(consumer);

    Events.subscribe(PlayerJoinEvent.class)
            .handler(e -> {
               refreshPlayer(e.getPlayer());
               refreshPlayer(e.getPlayer(), 20L);
            })
            .bindWith(consumer);

    Events.subscribe(PlayerQuitEvent.class)
            .handler(e -> e.getPlayer().removeAttachment(attachments.remove(e.getPlayer().getUniqueId())))
            .bindWith(consumer);
}

@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerLoginMonitor(PlayerLoginEvent e) {
    /* Listen to see if the event was cancelled after we initially handled the login
       If the connection was cancelled here, we need to do something to clean up the data that was loaded. */

    // Check to see if this connection was denied at LOW. Even if it was denied at LOW, their data will still be present.
    boolean denied = false;
    if (this.deniedLogin.remove(e.getPlayer().getUniqueId())) {
        denied = true;

        // This is a problem, as they were denied at low priority, but are now being allowed.
        if (e.getResult() == PlayerLoginEvent.Result.ALLOWED) {
            this.plugin.getLog().severe("Player connection was re-allowed for " + e.getPlayer().getUniqueId());
            e.disallow(PlayerLoginEvent.Result.KICK_OTHER, "");
        }
    }

    // Login event was cancelled by another plugin since we first loaded their data
    if (denied || e.getResult() != PlayerLoginEvent.Result.ALLOWED) {
        return;
    }

    // everything is going well. login was processed ok, this is just to refresh auto-op status.
    this.plugin.refreshAutoOp(this.plugin.getUserManager().getIfLoaded(e.getPlayer().getUniqueId()), e.getPlayer());
}

@SuppressWarnings("null")
@Override
public boolean init(final Expression<?>[] vars, final int matchedPattern, final Kleenean isDelayed, final ParseResult parser) {
    if (isDelayed == Kleenean.TRUE) {
        Skript.error("Can't cancel an event anymore after is has already passed", ErrorQuality.SEMANTIC_ERROR);
        return false;
    }
    cancel = matchedPattern == 0;
    final Class<? extends Event>[] es = ScriptLoader.getCurrentEvents();
    if (es == null)
        return false;
    for (final Class<? extends Event> e : es) {
        if (Cancellable.class.isAssignableFrom(e) || BlockCanBuildEvent.class.isAssignableFrom(e))
            return true; // TODO warning if some event(s) cannot be cancelled even though some can (needs a way to be suppressed)
    }
    if (ScriptLoader.isCurrentEvent(PlayerLoginEvent.class))
        Skript.error("A connect event cannot be cancelled, but the player may be kicked ('kick player by reason of \"...\"')", ErrorQuality.SEMANTIC_ERROR);
    else
        Skript.error(Utils.A(ScriptLoader.getCurrentEventName()) + " event cannot be cancelled", ErrorQuality.SEMANTIC_ERROR);
    return false;
}

@EventHandler
void onJoin(PlayerLoginEvent e) {
    if (BanManager.isBanido(e.getPlayer().getName())) {
        String[] ban = BanManager.getBan(e.getPlayer().getName()).split(";");
        String motivo = ban[2], admin = ban[3];
        int tempo = Integer.parseInt(ban[1]);
        if (tempo == 0) {
            e.disallow(Result.KICK_OTHER, MensagensManager.getMensagem("Ban.Join.Permanente").replace("<admin>", admin).replace("<motivo>", motivo));
            return;
        } 
        if (Utils.getTempoRestante(e.getPlayer().getName()) >= tempo) {
            BanManager.unbanPlayer(e.getPlayer().getName());
            return;
        }
        long tempoRestante = (tempo - Utils.getTempoRestante(e.getPlayer().getName()));
        e.disallow(Result.KICK_OTHER, MensagensManager.getMensagem("Ban.Join.Temporario").replace("<tempo>", Long.toString(tempoRestante)).replace("<admin>", admin).replace("<motivo>", motivo));
    } else if (BanManager.isIpBanido(e.getAddress().getHostName())) {
        e.disallow(Result.KICK_OTHER, MensagensManager.getMensagem("Ban.Join.Ip_Banido"));
    }
}

public static void init(JavaPlugin plugin) {
    Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
        try {
            BufferedReader reader = URLs.IP_CHECKER.openBufferedReader();
            address = reader.readLine();
        } catch (IOException e) {
            // Ignore
        }
    });
    Bukkit.getPluginManager().registerEvents(new Listener() {
        @EventHandler
        public void onLogin(PlayerLoginEvent event) throws UnknownHostException {
            String host = event.getHostname();
            String addrStr = host.substring(0, host.indexOf(':'));
            InetAddress addr = InetAddress.getByName(addrStr);
            if (!addr.isLoopbackAddress() && !addr.isSiteLocalAddress()) {
                address = addrStr;
                event.getHandlers().unregister(this);
            }
        }
    }, plugin);
}

/**
 * Creates a new player instance and adds it to the server
 * @param name The player name
 * @param uid The player UUID
 * @return The player instance
 */
public static TestPlayer createOnlinePlayer(String name, UUID uid) {        
    TestPlayer p = TestPlayer.create(name);

    final InetSocketAddress address = new InetSocketAddress("localhost", 25565);
    final AsyncPlayerPreLoginEvent preLoginEvent = new AsyncPlayerPreLoginEvent(name, address.getAddress(), uid);
    getPluginManager().callEvent(preLoginEvent);
    if (preLoginEvent.getLoginResult() != Result.ALLOWED) {
        return null;
    }

    final PlayerLoginEvent loginEvent = new PlayerLoginEvent(p, "localhost", address.getAddress());
    getPluginManager().callEvent(loginEvent);

    if (loginEvent.getResult() != PlayerLoginEvent.Result.ALLOWED) {
        return null;
    }

    final PlayerJoinEvent joinEvent = new PlayerJoinEvent(p, "");
    getPluginManager().callEvent(joinEvent);

    p.goOnline();
    return p;
}

@EventHandler(ignoreCancelled = false)
public void onPlayerLogin(cn.nukkit.event.player.PlayerLoginEvent event) {
    if (canIgnore(PlayerLoginEvent.getHandlerList())) {
        return;
    }

    Player bukkitPlayer = PokkitPlayer.toBukkit(event.getPlayer());
    InetAddress address = bukkitPlayer.getAddress().getAddress();

    PlayerLoginEvent bukkitEvent = new PlayerLoginEvent(bukkitPlayer, bukkitPlayer.getAddress().getHostName(),
            address, event.isCancelled() ? Result.KICK_OTHER : Result.ALLOWED, event.getKickMessage(), address);
    Bukkit.getPluginManager().callEvent(bukkitEvent);
    event.setCancelled(bukkitEvent.getResult() != Result.ALLOWED);

    event.setKickMessage(bukkitEvent.getKickMessage());
}

@EventHandler(priority = EventPriority.HIGHEST)
public void onPlayerLogin(PlayerLoginEvent e){
    Player player = e.getPlayer();
    if(plugin.getPlayerDatabase().isInDatabase(player)){
        PlayerDatabase.PlayerData playerData = plugin.getPlayerDatabase().getDataByUUID(player.getUniqueId().toString());
        if(playerData.isBanned()){
            long elapsed = System.currentTimeMillis() - playerData.getBanTime();
            int minutes = (((int) (elapsed / 1000)) / 60);
            if(minutes >= plugin.getTempBanTime()){
                playerData.setBanned(false);
                playerData.setLives(1);
                playerData.setSurvivalRecord(Long.toString(System.currentTimeMillis()));
                playerData.setBanTime(-1);
            } else {
                int difference = plugin.getTempBanTime() - minutes;
                int hourDiff = difference / 60;
                int minDiff = difference - (hourDiff * 60);
                String diff = hourDiff +" hours, "+minDiff+" minutes.";
                e.disallow(PlayerLoginEvent.Result.KICK_OTHER, "Your UDB ban is not over yet. You still have: "+diff);
            }
        }
    }
}

@EventHandler
void onPlayerLogin(PlayerLoginEvent e) {
    Player p = e.getPlayer();
    DeathManager deathManager = plugin.getManager().getDeathManager();
    if(p.hasPermission("scg.hardcore.bypass")) {
        return;
    }
    long bantime = deathManager.getPlayer(p.getName());
    if (bantime > System.currentTimeMillis()) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy HH:mm");
        Date date = new Date(bantime);
        String msg =  plugin.getManager().getSettingsManager().getHcKickMsg().replace("{TIME}", dateFormat.format(date));
        e.disallow(PlayerLoginEvent.Result.KICK_OTHER, ColoringUtil.colorText(msg));
    }else {
        deathManager.unbanPlayer(p.getName());
    }
}

private void registerBukkitEvents() {
    listener = new Listener() {

        @EventHandler(priority = EventPriority.LOWEST)
        public final void onPlayerLogin(PlayerLoginEvent e) {
            if (closed)
                return;

            Channel channel = getChannel(e.getPlayer());

            if (!uninjectedChannels.contains(channel)) {
                injectPlayer(e.getPlayer());
            }
        }

        @EventHandler
        public final void onPluginDisable(PluginDisableEvent e) {
            if (e.getPlugin().equals(plugin)) {
                close();
            }
        }

    };

    plugin.getServer().getPluginManager().registerEvents(listener, plugin);
}

@EventHandler(priority = EventPriority.LOWEST)
public void onPlayerLogin(final PlayerLoginEvent e) {
    debug("PlayerLoginEvent " + e.getPlayer().getName());
    debug("Player world " + e.getPlayer().getWorld().getName());

    if (cachedPlayers.containsKey(e.getPlayer().getUniqueId())) {
        // Player is cached. Continue load it.s
        loadCachedPlayer(e.getPlayer());
    } else {
        // Player is not cached, Load directly on Bukkit main thread.
        debug("onPlayerLogin player isn't cached, loading directly");
        loadPlayer(e.getPlayer().getUniqueId(), e.getPlayer().getName(), true, true);

        if (e.getResult() == PlayerLoginEvent.Result.ALLOWED)
            loadCachedPlayer(e.getPlayer());
    }
}

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
public void onLoginEvent(PlayerLoginEvent e) {
    if (plugin.cm.isFrontServer()) {

        if (plugin.pm.isBoggedDown(e.getPlayer())) {
            e.disallow(PlayerLoginEvent.Result.KICK_OTHER,
                    plugin.cm.getTarpittingPenaltyMessage());
            return;
        }

        if (!plugin.cm.isPremium()) {
            if (plugin.pm.isPremium(e.getPlayer())) {
                e.disallow(PlayerLoginEvent.Result.KICK_OTHER,
                        plugin.cm.getPremiumKickMessage());
                return;
            }
        }
        plugin.pm.spawn(e.getPlayer());
    }
}

private void registerBukkitEvents() {
    listener = new Listener() {

        @EventHandler(priority = EventPriority.LOWEST)
        public final void onPlayerLogin(PlayerLoginEvent e) {
            if (closed)
                return;

            Channel channel = getChannel(e.getPlayer());

            if (!uninjectedChannels.contains(channel))
                injectPlayer(e.getPlayer());
        }

        @EventHandler
        public final void onPluginDisable(PluginDisableEvent e) {
            if (e.getPlugin().equals(plugin)) {
                close();
            }
        }

    };

    plugin.getServer().getPluginManager().registerEvents(listener, plugin);
}

private void registerBukkitEvents() {
    listener = new Listener() {

        @EventHandler(priority = EventPriority.LOWEST)
        public final void onPlayerLogin(PlayerLoginEvent e) {
            if (closed)
                return;

            Channel channel = getChannel(e.getPlayer());

            if (!uninjectedChannels.contains(channel)) {
                injectPlayer(e.getPlayer());
            }
        }

        @EventHandler
        public final void onPluginDisable(PluginDisableEvent e) {
            if (e.getPlugin().equals(plugin)) {
                close();
            }
        }

    };

    plugin.getServer().getPluginManager().registerEvents(listener, plugin);
}

private void registerBukkitEvents() {
    listener = new Listener() {

        @EventHandler(priority = EventPriority.LOWEST)
        public final void onPlayerLogin(PlayerLoginEvent e) {
            if (closed)
                return;

            Channel channel = getChannel(e.getPlayer());

            if (!uninjectedChannels.contains(channel)) {
                injectPlayer(e.getPlayer());
            }
        }

        @EventHandler
        public final void onPluginDisable(PluginDisableEvent e) {
            if (e.getPlugin().equals(plugin)) {
                close();
            }
        }

    };

    plugin.getServer().getPluginManager().registerEvents(listener, plugin);
}

@Override
protected void checkBans(PlayerLoginEvent event, Object[] data) {
    String name = event.getPlayer().getName();
    String hostaddr = event.getAddress().getHostAddress();
    final BanList nameBans = server.getBanList(BanList.Type.NAME);
    final BanList ipBans = server.getBanList(BanList.Type.IP);
    if (nameBans.isBanned(name)) {
        event.disallow(PlayerLoginEvent.Result.KICK_BANNED, "Banned: " + nameBans.getBanEntry(name).getReason());
    } else if (ipBans.isBanned(hostaddr)) {
        event.disallow(PlayerLoginEvent.Result.KICK_BANNED, "Banned: " + ipBans.getBanEntry(hostaddr).getReason());
    } else if (server.hasWhitelist() && !event.getPlayer().isWhitelisted()) {
        event.disallow(PlayerLoginEvent.Result.KICK_WHITELIST, "You are not whitelisted on this server.");
    } else if (server.getOnlinePlayers().size() >= server.getMaxPlayers()) {
        event.disallow(PlayerLoginEvent.Result.KICK_FULL, "The server is full (" + server.getMaxPlayers() + " players).");
    }
}

/**
 * Triggered when a player TRIES to join the server.
 * @param e
 */
@EventHandler
public void onPlayerLogin(PlayerLoginEvent e)
{
    Player p = e.getPlayer();

    if (plugin.isInMaintenanceMode() && !p.isOp())
    {
        e.disallow(Result.KICK_OTHER,
                ChatColor.YELLOW + plugin.getMaintenanceMessage());
    }
    else if (SGOnline.getPlayerCount() >= plugin.getMaxPlayers())
    {
        e.disallow(Result.KICK_FULL, ChatColor.YELLOW
                + "Le serveur est plein !");
    }
}

@EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
public void onPlayerLogin(final PlayerLoginEvent event) {
    final Optional<CraftoPlayer> player = CraftoPlayer.getPlayer(event.getPlayer());
    if (!player.isPresent()) { CraftoMessenger.warnStaff("Cant find craftoplayer instance of " + event.getPlayer().getName() + "!"); return; }

    final Collection<Ban> bans = this.module.getBans(player.get());
    if (!bans.isEmpty()) {

        for (final Ban ban : bans) {
            if (!ban.hasExpired()) {
                if (ban.isKick()) {
                    event.disallow(Result.KICK_BANNED, this.module.kick.getKickMessage(ban));
                }
                else {
                    CraftoMessenger.warnStaff(player.get().getName() + " versucht zu connecten obwohl er noch gebannt ist.");
                    event.disallow(Result.KICK_BANNED, this.module.ban.getKickMessage(ban));
                }
            }
        }
    }
}

@EventHandler(priority = EventPriority.LOWEST)
public void tooManyLoggedInAccounts(PlayerLoginEvent event){ // Set to join because if kicked on login ip info isnt tracked.
    UUID name = event.getPlayer().getUniqueId();
    int count = 0;
    int allowed = plugin.getConfig().getInt("banmanager.set.altlimit");
    if (allowed == 0) return;
    List<UUID> alts = am.getAltsListUUID(name);
    Player[] players = Bukkit.getOnlinePlayers();
    for (Player p: players)
        if(alts.contains(p.getUniqueId())) count++;

    if (count > allowed){
        String reason = plugin.getConfig().getString("banmanager.set.altlimitreason");
        event.setKickMessage(reason);
        event.setResult(Result.KICK_BANNED);
    }
}

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
@Permission("crazylogin.warnsession")
@Localized({ "CRAZYLOGIN.KICKED.SESSION.DUPLICATE", "CRAZYLOGIN.SESSION.DUPLICATEWARN $Name$ $IP$" })
public void PlayerLoginSessionCheck(final PlayerLoginEvent event) {
    if (plugin.isForceSingleSessionEnabled()) {
        final Player player = event.getPlayer();
        if (player != null && player.isOnline()) {
            if (plugin.isForceSingleSessionSameIPBypassEnabled()) {
                final LoginPlayerData data = plugin.getPlayerData(player);
                if (data != null) {
                    if (event.getAddress().getHostAddress().equals(data.getLatestIP())) {
                        return;
                    }
                }
            }
            event.setResult(Result.KICK_OTHER);
            event.setKickMessage(plugin.getLocale().getLocaleMessage(player, "KICKED.SESSION.DUPLICATE"));
            plugin.broadcastLocaleMessage(true, "crazylogin.warnsession", true, "SESSION.DUPLICATEWARN", player.getName(), event.getAddress().getHostAddress());
            plugin.sendLocaleMessage("SESSION.DUPLICATEWARN", player, event.getAddress().getHostAddress(), player.getName());
            plugin.getCrazyLogger().log("AccessDenied", "Denied access for player " + player.getName() + " @ " + event.getAddress().getHostAddress() + " because of a player with this name being already online");
            return;
        }
    }
}

@EventHandler
public void onPlayerLoginAdd(PlayerLoginEvent e){
    Player p = e.getPlayer();
    Main.playerList.add(p);

    //DB Stuff
    PlayerTbl player = Main.db.getPlayer(p.getName());
    if(player != null) {
        player.setOnline(true);
        Main.db.getDB().save(player);
    } else {
        PlayerTbl newPlayer = new PlayerTbl();
        newPlayer.setOnline(true);
        newPlayer.setName(p.getName());
        Main.db.getDB().save(newPlayer);
    }
    //End DB Stuff
}

@EventHandler(priority = EventPriority.NORMAL)
public void onPlayerLogin(final PlayerLoginEvent event) {
    if (event.getResult() == Result.ALLOWED) {
        final UUID id = event.getPlayer().getUniqueId();
        final String playerIp = event.getAddress().getHostAddress();
        if (this.punishmentDb.isIdBanned(id)) {
            final Punishment ban = this.punishmentDb.get(id.toString(), PunishmentType.BAN);
            final String playerBannedMessage;
            if (ban.isPermanent()) {
                playerBannedMessage = this.plugin.getMessages().get(MessageId.player_deniedPermBanned, ban.getReason())[0];
            } else {
                playerBannedMessage = this.plugin.getMessages().get(MessageId.player_deniedTempBanned, ban.getReason(), TimeUtil.toString((ban.getEndDate() - System.currentTimeMillis()) / 1000))[0];
            }
            event.disallow(PlayerLoginEvent.Result.KICK_BANNED, playerBannedMessage);
        } else if (this.punishmentDb.isIpBanned(playerIp)) {
            final Punishment ipBan = this.punishmentDb.get(playerIp, PunishmentType.IPBAN);
            final String ipBannedMessage;
            if (ipBan.isPermanent()) {
                ipBannedMessage = this.plugin.getMessages().get(MessageId.player_deniedPermIpBanned, ipBan.getReason())[0];
            } else {
                ipBannedMessage = this.plugin.getMessages().get(MessageId.player_deniedTempIpBanned, ipBan.getReason(), TimeUtil.toString((ipBan.getEndDate() - System.currentTimeMillis()) / 1000))[0];
            }
            event.disallow(PlayerLoginEvent.Result.KICK_BANNED, ipBannedMessage);
        }
    }
}

@EventHandler
public void onLogin(PlayerLoginEvent event) {
    final Player p = event.getPlayer();
    if (event.getResult().equals(PlayerLoginEvent.Result.ALLOWED)) {
        new BukkitRunnable() {
            @Override
            public void run() {
                if (p != null) {
                    EffectHolder eh = EffectManager.getInstance().createFromFile(p.getName());
                    if (eh != null && !eh.getEffects().isEmpty()) {
                        Lang.sendTo(p, Lang.EFFECTS_LOADED.toString());
                    }
                }
            }
        }.runTaskLater(SparkTrailPlugin.getInstance(), 20L);
    }
}

@EventHandler(priority = EventPriority.LOW)
public void onPlayerLogin(PlayerLoginEvent event) {
    final Player player = event.getPlayer();
    final String name = player.getName();

    if (validationService.isUnrestricted(name)) {
        return;
    }

    if (onJoinVerifier.refusePlayerForFullServer(event)) {
        return;
    }
    if (event.getResult() != PlayerLoginEvent.Result.ALLOWED) {
        return;
    }

    if (!isAsyncPlayerPreLoginEventCalled || !settings.getProperty(PluginSettings.USE_ASYNC_PRE_LOGIN_EVENT)) {
        try {
            runOnJoinChecks(JoiningPlayer.fromPlayerObject(player), event.getAddress().getHostAddress());
        } catch (FailedVerificationException e) {
            event.setKickMessage(m.retrieveSingle(e.getReason(), e.getArgs()));
            event.setResult(PlayerLoginEvent.Result.KICK_OTHER);
        }
    }
}

@Test
public void shouldNotInterfereWithUnrestrictedUser() {
    // given
    String name = "Player01";
    Player player = mockPlayerWithName(name);
    PlayerLoginEvent event = spy(new PlayerLoginEvent(player, "", null));
    given(validationService.isUnrestricted(name)).willReturn(true);

    // when
    listener.onPlayerLogin(event);

    // then
    verify(validationService).isUnrestricted(name);
    verifyNoModifyingCalls(event);
    verifyZeroInteractions(onJoinVerifier);
}

@Test
public void shouldStopHandlingForFullServer() {
    // given
    String name = "someone";
    Player player = mockPlayerWithName(name);
    PlayerLoginEvent event = spy(new PlayerLoginEvent(player, "", null));
    given(validationService.isUnrestricted(name)).willReturn(false);
    given(onJoinVerifier.refusePlayerForFullServer(event)).willReturn(true);

    // when
    listener.onPlayerLogin(event);

    // then
    verify(validationService).isUnrestricted(name);
    verify(onJoinVerifier, only()).refusePlayerForFullServer(event);
    verifyNoModifyingCalls(event);
}

@Test
public void shouldStopHandlingEventForBadResult() {
    // given
    String name = "someone";
    Player player = mockPlayerWithName(name);
    PlayerLoginEvent event = new PlayerLoginEvent(player, "", null);
    event.setResult(PlayerLoginEvent.Result.KICK_BANNED);
    event = spy(event);
    given(validationService.isUnrestricted(name)).willReturn(false);
    given(onJoinVerifier.refusePlayerForFullServer(event)).willReturn(false);

    // when
    listener.onPlayerLogin(event);

    // then
    verify(validationService).isUnrestricted(name);
    verify(onJoinVerifier, only()).refusePlayerForFullServer(event);
    verifyNoModifyingCalls(event);
}

@Test
public void shouldRefuseNonVipPlayerForFullServer() {
    // given
    Player player = mock(Player.class);
    PlayerLoginEvent event = new PlayerLoginEvent(player, "hostname", null);
    event.setResult(PlayerLoginEvent.Result.KICK_FULL);
    given(permissionsManager.hasPermission(player, PlayerStatePermission.IS_VIP)).willReturn(false);
    String serverFullMessage = "server is full";
    given(messages.retrieveSingle(MessageKey.KICK_FULL_SERVER)).willReturn(serverFullMessage);

    // when
    boolean result = onJoinVerifier.refusePlayerForFullServer(event);

    // then
    assertThat(result, equalTo(true));
    assertThat(event.getResult(), equalTo(PlayerLoginEvent.Result.KICK_FULL));
    assertThat(event.getKickMessage(), equalTo(serverFullMessage));
    verifyZeroInteractions(bukkitService, dataSource);
}

@Test
public void shouldKickNonVipForJoiningVipPlayer() {
    // given
    Player player = mock(Player.class);
    PlayerLoginEvent event = new PlayerLoginEvent(player, "hostname", null);
    event.setResult(PlayerLoginEvent.Result.KICK_FULL);
    given(permissionsManager.hasPermission(player, PlayerStatePermission.IS_VIP)).willReturn(true);
    List<Player> onlinePlayers = Arrays.asList(mock(Player.class), mock(Player.class));
    given(permissionsManager.hasPermission(onlinePlayers.get(0), PlayerStatePermission.IS_VIP)).willReturn(true);
    given(permissionsManager.hasPermission(onlinePlayers.get(1), PlayerStatePermission.IS_VIP)).willReturn(false);
    returnOnlineListFromBukkitServer(onlinePlayers);
    given(server.getMaxPlayers()).willReturn(onlinePlayers.size());
    given(messages.retrieveSingle(MessageKey.KICK_FOR_VIP)).willReturn("kick for vip");

    // when
    boolean result = onJoinVerifier.refusePlayerForFullServer(event);

    // then
    assertThat(result, equalTo(false));
    assertThat(event.getResult(), equalTo(PlayerLoginEvent.Result.ALLOWED));
    // First player is VIP, so expect no interactions there and second player to have been kicked
    verifyZeroInteractions(onlinePlayers.get(0));
    verify(onlinePlayers.get(1)).kickPlayer("kick for vip");
}

@Test
public void shouldKickVipPlayerIfNoPlayerCanBeKicked() {
    // given
    Player player = mock(Player.class);
    PlayerLoginEvent event = new PlayerLoginEvent(player, "hostname", null);
    event.setResult(PlayerLoginEvent.Result.KICK_FULL);
    given(permissionsManager.hasPermission(player, PlayerStatePermission.IS_VIP)).willReturn(true);
    List<Player> onlinePlayers = Collections.singletonList(mock(Player.class));
    given(permissionsManager.hasPermission(onlinePlayers.get(0), PlayerStatePermission.IS_VIP)).willReturn(true);
    returnOnlineListFromBukkitServer(onlinePlayers);
    given(server.getMaxPlayers()).willReturn(onlinePlayers.size());
    given(messages.retrieveSingle(MessageKey.KICK_FULL_SERVER)).willReturn("kick full server");

    // when
    boolean result = onJoinVerifier.refusePlayerForFullServer(event);

    // then
    assertThat(result, equalTo(true));
    assertThat(event.getResult(), equalTo(PlayerLoginEvent.Result.KICK_FULL));
    assertThat(event.getKickMessage(), equalTo("kick full server"));
    verifyZeroInteractions(onlinePlayers.get(0));
}

@EventHandler
private void onPlayerLogin(PlayerLoginEvent ple) {
  try {
    String requiredKey = plugin.getConfig().getString("users." + ple.getPlayer().getName());
    String hostname = ple.getHostname();
    String key = hostname.split("\\.")[0];
    String hash = DnsLoginPlugin.calculateHash(key);
    if(hash.equals(requiredKey))
      return;
    plugin.getLogger().info("Login attempt with username " + ple.getPlayer().getName() + " disallowed. DnsLogin key was not found");
    ple.disallow(PlayerLoginEvent.Result.KICK_WHITELIST, "Player not whitelisted.");
  } catch (Exception e) {
    ple.disallow(PlayerLoginEvent.Result.KICK_WHITELIST, "Player not whitelisted.");
    e.printStackTrace();
  }
}

@EventHandler
public void banHandler(PlayerLoginEvent e) {
    Player p = e.getPlayer();
    PConfManager pcm = PConfManager.getPConfManager(p);
    if (!pcm.isSet("banned") || !pcm.isSet("banexpiresafter")) return;
    boolean banned = pcm.getBoolean("banned");
    long banExpiresAfter = pcm.getLong("banexpiresafter");
    if (!banned || banExpiresAfter <= 0L) return;
    // if time now is after the time ban should expire
    if (System.currentTimeMillis() > banExpiresAfter) {
        p.setBanned(false);
        e.setResult(PlayerLoginEvent.Result.ALLOWED);
        pcm.set("banned", false);
        pcm.set("banexpiresafter", null);
        return;
    }
    e.setResult(PlayerLoginEvent.Result.KICK_BANNED);
    e.setKickMessage(Config.banMessage);
}

@EventHandler(
        ignoreCancelled = false,
        priority = EventPriority.HIGH)
public void operatorFullJoin(PlayerLoginEvent e) {
    Player player = e.getPlayer();// Caches players into a local UUID map
    if(!Bssentials.uuid_map.containsKey(player.getName())) {
        Bssentials.uuid_map.put(player.getName(), player.getUniqueId());
    }
    if(player.isOp() && e.getResult() == Result.KICK_FULL && !player.isBanned()) {
        e.allow();
    }
}