initial commit

.gitignore

@@ -0,0 +1,38 @@
+# Plugin
+.idea
+run
+
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# IntelliJ
+*.iml
+*.ipr
+*.iws
+.idea/
+out/
+
+# Maven
+target/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+

pom.xml

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>groupId</groupId>
+    <artifactId>LiteFlags</artifactId>
+    <version>0.5</version>
+
+    <properties>
+        <maven.compiler.source>11</maven.compiler.source>
+        <maven.compiler.target>11</maven.compiler.target>
+    </properties>
+    <build>
+        <finalName>${project.artifactId}</finalName>
+        <defaultGoal>clean package install</defaultGoal>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.5.1</version>
+                <configuration>
+                    <source>11</source>
+                    <target>11</target>
+                </configuration>
+            </plugin>
+        </plugins>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+            </resource>
+        </resources>
+    </build>
+
+    <repositories>
+        <repository>
+            <id>papermc</id>
+            <url>https://papermc.io/repo/repository/maven-public/</url>
+        </repository>
+    </repositories>
+    <dependencies>
+        <dependency>
+            <groupId>com.destroystokyo.paper</groupId>
+            <artifactId>paper-api</artifactId>
+            <version>1.16.5-R0.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+    
+</project>

src/main/java/com/liteflags/LiteFlags.java

@@ -0,0 +1,50 @@
+package com.liteflags;
+
+import com.liteflags.auth.AuthTimer;
+import com.liteflags.commands.FlagCMD;
+import com.liteflags.data.database.DatabaseConnection;
+import com.liteflags.events.ChatEvent;
+import com.liteflags.events.LoginEvent;
+import com.liteflags.events.LogoutEvent;
+import com.liteflags.events.MoveEvent;
+import java.sql.SQLException;
+import org.bukkit.plugin.java.JavaPlugin;
+
+public class LiteFlags extends JavaPlugin {
+   private static LiteFlags instance;
+   public DatabaseConnection database;
+   public AuthTimer timer;
+
+   public void onEnable() {
+      instance = this;
+      this.saveDefaultConfig();
+      this.getCommand("flag").setExecutor(new FlagCMD(this));
+      this.getCommand("flaglist").setExecutor(new FlagCMD(this));
+      this.getServer().getPluginManager().registerEvents(new LoginEvent(this), this);
+      this.getServer().getPluginManager().registerEvents(new LogoutEvent(this), this);
+      this.getServer().getPluginManager().registerEvents(new ChatEvent(this), this);
+      this.getServer().getPluginManager().registerEvents(new MoveEvent(this), this);
+
+      try {
+         DatabaseConnection var10000 = this.database;
+         DatabaseConnection.initialize();
+      } catch (SQLException var2) {
+         this.getLogger().severe("*** Could not connect to the database. ***");
+         this.getLogger().severe("*** This plugin will be disabled. ***");
+         this.setEnabled(false);
+         var2.printStackTrace();
+      }
+
+   }
+
+   public void onDisable() {
+   }
+
+   public static LiteFlags getInstance() {
+      return instance;
+   }
+
+   public AuthTimer authTimer() {
+      return this.timer;
+   }
+}

src/main/java/com/liteflags/auth/AuthTimer.java

@@ -0,0 +1,53 @@
+package com.liteflags.auth;
+
+import com.liteflags.LiteFlags;
+import com.liteflags.data.maps.MapCache;
+import com.liteflags.util.Utilities;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+public class AuthTimer<taskID> {
+   public LiteFlags flags;
+   public static Map<UUID, Integer> taskID = new HashMap();
+
+   public AuthTimer(LiteFlags flags) {
+      this.flags = flags;
+   }
+
+   public static void startTimer(final Player player) {
+      int tid = LiteFlags.getInstance().getServer().getScheduler().scheduleSyncRepeatingTask(LiteFlags.getInstance(), new Runnable() {
+         int timeRemaining = LiteFlags.getInstance().getConfig().getInt("Authenticate_Timer");
+
+         public void run() {
+            if (this.timeRemaining <= 0) {
+               if (player.hasPermission("liteflags.authentication.success")) {
+                  AuthTimer.endTask(player);
+               } else {
+                  player.sendMessage(Utilities.format(LiteFlags.getInstance().getConfig().getString("Messages.Authenticate").replace("%code%", (CharSequence)MapCache.reauthedPlayers.get(player.getUniqueId().toString()))));
+                  Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), LiteFlags.getInstance().getConfig().getString("Authenticate_Timer_Command").replace("%player%", player.getName()).replace("%code%", (CharSequence)MapCache.reauthedPlayers.get(player.getUniqueId().toString())));
+                  this.timeRemaining = LiteFlags.getInstance().getConfig().getInt("Authenticate_Timer");
+               }
+            } else if (player.hasPermission("liteflags.authentication.success")) {
+               AuthTimer.endTask(player);
+            } else {
+               --this.timeRemaining;
+            }
+
+         }
+      }, 0L, 20L);
+      Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), LiteFlags.getInstance().getConfig().getString("Authenticate_Timer_Command").replace("%player%", player.getName()).replace("%code%", (CharSequence)MapCache.reauthedPlayers.get(player.getUniqueId().toString())));
+      taskID.put(player.getUniqueId(), tid);
+   }
+
+   public static void endTask(Player player) {
+      if (taskID.containsKey(player.getUniqueId())) {
+         int tid = (Integer)taskID.get(player.getUniqueId());
+         LiteFlags.getInstance().getServer().getScheduler().cancelTask(tid);
+         taskID.remove(player.getUniqueId());
+      }
+
+   }
+}

src/main/java/com/liteflags/auth/Authentication.java

@@ -0,0 +1,34 @@
+package com.liteflags.auth;
+
+import com.liteflags.LiteFlags;
+import com.liteflags.data.maps.MapCache;
+import com.liteflags.util.Utilities;
+import java.util.Random;
+import java.util.UUID;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+public class Authentication {
+   public static String getAuthKey() {
+      String randChars = "ABCDEFGHIJKLMNPQRSTUVWXYZ123456789abcdefghijklmnopqrstuvwsyz";
+      StringBuilder salt = new StringBuilder();
+      Random rnd = new Random();
+
+      while(salt.length() < 6) {
+         int index = (int)(rnd.nextFloat() * (float)randChars.length());
+         salt.append(randChars.charAt(index));
+      }
+
+      return "." + salt.toString();
+   }
+
+   public static void checkAuthStatus(UUID uuid) {
+      Player player = Bukkit.getPlayer(uuid);
+      if (!player.hasPermission("liteflags.authentication.success")) {
+         MapCache.reauthedPlayers.put(player.getUniqueId().toString(), getAuthKey());
+         AuthTimer.startTimer(player);
+         player.sendMessage(Utilities.format(LiteFlags.getInstance().getConfig().getString("Messages.Authenticate").replace("%code%", (CharSequence)MapCache.reauthedPlayers.get(player.getUniqueId().toString()))));
+      }
+
+   }
+}

src/main/java/com/liteflags/commands/AuthCMD.java

@@ -0,0 +1,4 @@
+package com.liteflags.commands;
+
+public class AuthCMD {
+}

src/main/java/com/liteflags/commands/FlagCMD.java

@@ -0,0 +1,283 @@
+package com.liteflags.commands;
+
+import com.liteflags.LiteFlags;
+import com.liteflags.data.database.Database;
+import com.liteflags.data.database.Methods;
+import com.liteflags.data.maps.MapCache;
+import com.liteflags.util.Utilities;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import net.md_5.bungee.api.chat.ClickEvent;
+import net.md_5.bungee.api.chat.ComponentBuilder;
+import net.md_5.bungee.api.chat.HoverEvent;
+import net.md_5.bungee.api.chat.TextComponent;
+import net.md_5.bungee.api.chat.HoverEvent.Action;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class FlagCMD implements CommandExecutor {
+   private LiteFlags flags;
+
+   public FlagCMD(LiteFlags flags) {
+      this.flags = flags;
+   }
+
+   public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+      OfflinePlayer target;
+      String removeTimeLetter;
+      if (cmd.getName().equalsIgnoreCase("flag") && sender instanceof Player) {
+         if (sender.hasPermission("liteflags.staff")) {
+            if (args.length == 0) {
+               sender.sendMessage(ChatColor.RED + "Invalid command. /flag help");
+            }
+
+            if (args.length == 1 && args[0].equalsIgnoreCase("help")) {
+               sender.sendMessage(ChatColor.YELLOW + "/flaglist | /fl " + ChatColor.GRAY + "- Shows all the players with active flags");
+               sender.sendMessage(ChatColor.YELLOW + "/flaglist | /fl <player> " + ChatColor.GRAY + "- Shows all flags a player has");
+               sender.sendMessage(ChatColor.YELLOW + "/flag <player> <time> <reason> " + ChatColor.GRAY + "- This will flag a player for a given reason. Ex: /flag BobTheBuilder 7d Possible hacked client.");
+            }
+
+            if (args.length >= 2) {
+               if (args[0].equalsIgnoreCase("remove")) {
+                  if (sender.hasPermission("liteflags.removeflags")) {
+                     target = Bukkit.getServer().getOfflinePlayer(args[2]);
+                     int id = Integer.parseInt(args[1]);
+                     if (args.length == 4) {
+                        if (!args[3].isEmpty() && args[3].equalsIgnoreCase("-c") && Database.hasFlags(target.getUniqueId())) {
+                           sender.sendMessage(ChatColor.GRAY + "You have successfully removed the flag '" + Database.getFlagReason(target.getUniqueId(), id) + "' from " + ChatColor.YELLOW + target.getName() + "'s" + ChatColor.GRAY + " flag history.");
+                           LiteFlags.getInstance().getLogger().info(sender.getName() + " has removed the flag '" + Database.getFlagReason(target.getUniqueId(), id) + "' from " + target.getName() + "'s flag history.");
+                           Database.removeFlag(target.getUniqueId(), id);
+                        }
+                     } else if (args.length == 3) {
+                        Utilities.sendFlagConfirmMessage(sender, target, id, Database.getFlagReason(target.getUniqueId(), id));
+                     }
+                  } else {
+                     sender.sendMessage(Utilities.format(LiteFlags.getInstance().getConfig().getString("Messages.NoPermission")));
+                  }
+               } else {
+                  target = Bukkit.getServer().getOfflinePlayer(args[0]);
+                  if (Methods.getTotalActiveFlags(target) < LiteFlags.getInstance().getConfig().getInt("ActiveFlags.Limit")) {
+                     if (target != null) {
+                        if (!args[1].equals("*")) {
+                           removeTimeLetter = removeLastChar(args[1]);
+                           if (!removeTimeLetter.isEmpty()) {
+                              if (this.isInt(removeTimeLetter)) {
+                                 String getLetter = getLastChar(args[1]);
+                                 String[] validTimes = new String[]{"d", "h", "m"};
+                                 if (Arrays.asList(validTimes).contains(getLetter)) {
+                                    int number = Integer.parseInt(removeTimeLetter);
+                                    int timeInMin = this.convertTimeToMinutes(number, getLetter);
+                                    long currentTime = TimeUnit.MILLISECONDS.toMinutes(System.currentTimeMillis());
+                                    int conTime = (int)currentTime + timeInMin;
+                                    StringBuilder reason = new StringBuilder();
+
+                                    for(int i = 2; i < args.length; ++i) {
+                                       if (i > 2) {
+                                          reason.append(" ");
+                                       }
+
+                                       reason.append(args[i]);
+                                    }
+
+                                    Database.addFlag(target.getUniqueId(), (long)((int)TimeUnit.MINUTES.toSeconds((long)conTime)), reason.toString(), sender.getName(), Utilities.convertTime(timeInMin));
+                                    if (target.isOnline() && !MapCache.activeFlags.contains(target.getName())) {
+                                       MapCache.activeFlags.add(target.getName());
+                                    }
+
+                                    Iterator var25 = Bukkit.getOnlinePlayers().iterator();
+
+                                    while(var25.hasNext()) {
+                                       Player staff = (Player)var25.next();
+                                       if (staff.hasPermission("liteflags.alertflags")) {
+                                          staff.sendMessage(Utilities.format(LiteFlags.getInstance().getConfig().getString("Messages.FlaggedPlayer").replace("%staff%", sender.getName()).replace("%player%", target.getName()).replace("%flaglength%", Utilities.convertTime(timeInMin)).replace("%reason%", reason.toString())));
+                                       }
+                                    }
+                                 } else {
+                                    sender.sendMessage(ChatColor.RED + getLetter + " is not a valid letter. (d, h, m)");
+                                 }
+                              } else {
+                                 sender.sendMessage(ChatColor.RED + removeTimeLetter + " is not a valid number.");
+                              }
+                           } else {
+                              sender.sendMessage(ChatColor.RED + "Invalid time argument! Example: 1d");
+                           }
+                        } else if (sender.hasPermission("liteflags.flagperm")) {
+                           StringBuilder reason = new StringBuilder();
+
+                           for(int i = 2; i < args.length; ++i) {
+                              if (i > 2) {
+                                 reason.append(" ");
+                              }
+
+                              reason.append(args[i]);
+                           }
+
+                           Database.addFlag(target.getUniqueId(), 0L, reason.toString(), sender.getName(), "Permanent");
+                           if (!MapCache.activeFlags.contains(target.getName())) {
+                              MapCache.activeFlags.add(target.getName());
+                           }
+
+                           Iterator var21 = Bukkit.getOnlinePlayers().iterator();
+
+                           while(var21.hasNext()) {
+                              Player staff = (Player)var21.next();
+                              if (staff.hasPermission("liteflags.alertflags")) {
+                                 staff.sendMessage(Utilities.format(LiteFlags.getInstance().getConfig().getString("Messages.FlaggedPlayer").replace("%staff%", sender.getName()).replace("%player%", target.getName()).replace("%flaglength%", "Permanent").replace("%reason%", reason.toString())));
+                              }
+                           }
+                        } else {
+                           sender.sendMessage(ChatColor.RED + "You do not have permission to flag permanently.");
+                        }
+                     } else {
+                        sender.sendMessage(target.getName() + " is not a valid username!");
+                     }
+                  } else {
+                     sender.sendMessage(Utilities.format(LiteFlags.getInstance().getConfig().getString("Messages.ActiveFlagsLimit").replace("%player%", target.getName())));
+                  }
+               }
+            }
+         } else {
+            sender.sendMessage(Utilities.format(LiteFlags.getInstance().getConfig().getString("Messages.NoPermission")));
+         }
+      }
+
+      if (cmd.getName().equalsIgnoreCase("flaglist")) {
+         if (sender.hasPermission("liteflags.staff")) {
+            if (args.length == 0) {
+               if (MapCache.activeFlags.size() > 0) {
+                  Iterator var17 = MapCache.activeFlags.iterator();
+
+                  while(var17.hasNext()) {
+                     removeTimeLetter = (String)var17.next();
+                     OfflinePlayer afPlayer = Bukkit.getServer().getOfflinePlayer(removeTimeLetter);
+                     int totalFlags = Methods.getTotalActiveFlags(afPlayer);
+                     Utilities.sendStaffHoverMessage(afPlayer, (Player)sender, Utilities.format(LiteFlags.getInstance().getConfig().getString("Messages.AlertActiveFlags").replace("%player%", afPlayer.getName()).replace("%totalactflags%", "" + totalFlags).replace("%consoleFlags%", "" + Methods.consoleFlags).replace("%staffFlags%", "" + Methods.staffFlags)));
+                  }
+               } else {
+                  sender.sendMessage(ChatColor.GRAY + "No players have active flags.");
+               }
+            }
+
+            if (args.length >= 1) {
+               target = Bukkit.getServer().getOfflinePlayer(args[0]);
+               this.sendFlagMessage(sender, target);
+            }
+         } else {
+            sender.sendMessage(Utilities.format(LiteFlags.getInstance().getConfig().getString("Messages.NoPermission")));
+         }
+      }
+
+      return false;
+   }
+
+   private static String getLastChar(String str) {
+      return str.substring(str.length() - 1);
+   }
+
+   private static String removeLastChar(String str) {
+      return str.substring(0, str.length() - 1);
+   }
+
+   public int convertTimeToMinutes(int number, String dhm) {
+      if (dhm.equalsIgnoreCase("d")) {
+         return 1440 * number;
+      } else {
+         return dhm.equalsIgnoreCase("h") ? 60 * number : number;
+      }
+   }
+
+   public boolean isInt(String s) {
+      try {
+         Integer.parseInt(s);
+         return true;
+      } catch (NumberFormatException var3) {
+         return false;
+      }
+   }
+
+   public void sendFlagMessage(CommandSender sender, OfflinePlayer targetPlayer) {
+      List<String> body = LiteFlags.getInstance().getConfig().getStringList("Messages.PlayerFlagsBody");
+      int i = 0;
+      int id = false;
+      boolean headerMessage = false;
+      if (Database.hasFlags(targetPlayer.getUniqueId())) {
+         try {
+            ResultSet flag = Database.getPlayerFlags(targetPlayer.getUniqueId());
+
+            label52:
+            while(flag.next()) {
+               long expireTime = TimeUnit.SECONDS.toMinutes((long)flag.getInt("expire_time"));
+               long timeFlagged = TimeUnit.SECONDS.toMinutes((long)flag.getInt("time_flagged"));
+               long currentTime = TimeUnit.SECONDS.toMinutes(System.currentTimeMillis() / 1000L);
+               int convertedExpireTime = (int)expireTime - (int)currentTime;
+               int convertedFlaggedTime = (int)currentTime - (int)timeFlagged;
+               String flaggedBy = flag.getString("flagged_by");
+               String flagLength = flag.getString("flag_length");
+               String reason = flag.getString("reason");
+               int id = flag.getInt("id");
+               TextComponent mainComponent = null;
+               Iterator var20 = body.iterator();
+
+               while(true) {
+                  while(true) {
+                     if (!var20.hasNext()) {
+                        continue label52;
+                     }
+
+                     String s = (String)var20.next();
+                     s = s.replaceFirst("%player%", targetPlayer.getName());
+                     s = s.replaceFirst("%staff%", flaggedBy);
+                     s = s.replaceFirst("%flaglength%", flagLength);
+                     s = s.replaceFirst("%reason%", reason);
+                     s = s.replaceFirst("%flagtime%", Utilities.convertTime(convertedFlaggedTime));
+                     if (expireTime != 0L) {
+                        s = s.replaceFirst("%expiretime%", Utilities.convertTime(convertedExpireTime));
+                     }
+
+                     s = s.replaceFirst("%limit%", "" + Database.countFlags(targetPlayer.getUniqueId()));
+                     s = s.replaceFirst("%nl%", " ");
+                     if (convertedExpireTime < 0 && expireTime != 0L) {
+                        s = s.replaceFirst("%active%", LiteFlags.getInstance().getConfig().getString("Messages.ExpiredFlags"));
+                        mainComponent = new TextComponent(Utilities.format(s));
+                     } else {
+                        s = s.replaceFirst("%active%", LiteFlags.getInstance().getConfig().getString("Messages.ActiveFlags"));
+                        mainComponent = new TextComponent(Utilities.format(s));
+                     }
+
+                     if (!headerMessage) {
+                        headerMessage = true;
+                        sender.sendMessage(Utilities.format(LiteFlags.getInstance().getConfig().getString("Messages.PlayerFlagsHeader").replace("%limit%", "" + Database.countFlags(targetPlayer.getUniqueId()))));
+                     }
+
+                     if (!s.contains(LiteFlags.getInstance().getConfig().getString("Messages.ActiveFlags")) && !s.contains(LiteFlags.getInstance().getConfig().getString("Messages.ExpiredFlags"))) {
+                        sender.sendMessage(Utilities.format(s));
+                     } else {
+                        mainComponent.setColor(net.md_5.bungee.api.ChatColor.GOLD);
+                        TextComponent removeButton = new TextComponent("[✖]");
+                        removeButton.setColor(net.md_5.bungee.api.ChatColor.GRAY);
+                        removeButton.setHoverEvent(new HoverEvent(Action.SHOW_TEXT, (new ComponentBuilder(net.md_5.bungee.api.ChatColor.GRAY + "Click to remove this flag")).create()));
+                        removeButton.setClickEvent(new ClickEvent(net.md_5.bungee.api.chat.ClickEvent.Action.RUN_COMMAND, "/flag remove " + id + " " + targetPlayer.getName()));
+                        mainComponent.addExtra(removeButton);
+                        sender.spigot().sendMessage(mainComponent);
+                     }
+                  }
+               }
+            }
+         } catch (SQLException var23) {
+            var23.printStackTrace();
+         }
+      } else {
+         sender.sendMessage(Utilities.format(LiteFlags.getInstance().getConfig().getString("Messages.PlayerFlagsHeader").replace("%limit%", "" + i)));
+      }
+
+   }
+}

src/main/java/com/liteflags/data/Data.java

@@ -0,0 +1,4 @@
+package com.liteflags.data;
+
+public class Data {
+}

src/main/java/com/liteflags/data/database/Database.java

@@ -0,0 +1,233 @@
+package com.liteflags.data.database;
+
+import com.liteflags.LiteFlags;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.UUID;
+
+public class Database {
+   public static void createTables() {
+      String player_flags = "CREATE TABLE IF NOT EXISTS player_flags (\n id INTEGER NOT NULL AUTO_INCREMENT,\n uuid VARCHAR(36) NOT NULL,\n  expire_time INTEGER(12),\n reason VARCHAR(256) NOT NULL,\n flagged_by VARCHAR(16) NOT NULL,\n time_flagged INTEGER(16) NOT NULL,\n flag_length VARCHAR(36) NOT NULL,\n PRIMARY KEY(ID)\n);";
+      String player_cache = "CREATE TABLE IF NOT EXISTS player_cache (\n uuid VARCHAR(36) NOT NULL,\n player_name VARCHAR(16),\n PRIMARY KEY(uuid)\n);";
+
+      try {
+         Statement statement = DatabaseConnection.getConnection().createStatement();
+         statement.execute(player_flags);
+         statement.execute(player_cache);
+      } catch (SQLException var3) {
+         var3.printStackTrace();
+      }
+
+   }
+
+   public static void addFlag(UUID uuid, long expireTime, String reason, String flaggedBy, String flagLength) {
+      int timeFlagged = (int)(System.currentTimeMillis() / 1000L);
+      String sql = "INSERT INTO player_flags (uuid, expire_time, reason, flagged_by, time_flagged, flag_length) VALUES (?, ?, ?, ?, ?, ?)";
+
+      try {
+         PreparedStatement statement = DatabaseConnection.getConnection().prepareStatement(sql);
+         Throwable var9 = null;
+
+         try {
+            statement.setString(1, uuid.toString());
+            statement.setLong(2, expireTime);
+            statement.setString(3, reason);
+            statement.setString(4, flaggedBy);
+            statement.setInt(5, timeFlagged);
+            statement.setString(6, flagLength);
+            statement.execute();
+         } catch (Throwable var19) {
+            var9 = var19;
+            throw var19;
+         } finally {
+            if (statement != null) {
+               if (var9 != null) {
+                  try {
+                     statement.close();
+                  } catch (Throwable var18) {
+                     var9.addSuppressed(var18);
+                  }
+               } else {
+                  statement.close();
+               }
+            }
+
+         }
+      } catch (SQLException var21) {
+         var21.printStackTrace();
+      }
+
+   }
+
+   public static void removeFlag(UUID uuid, int id) {
+      String sql = "DELETE FROM player_flags WHERE uuid = ? AND id = ?";
+
+      try {
+         PreparedStatement statement = DatabaseConnection.getConnection().prepareStatement(sql);
+         Throwable var4 = null;
+
+         try {
+            statement.setString(1, uuid.toString());
+            statement.setInt(2, id);
+            statement.executeUpdate();
+         } catch (Throwable var14) {
+            var4 = var14;
+            throw var14;
+         } finally {
+            if (statement != null) {
+               if (var4 != null) {
+                  try {
+                     statement.close();
+                  } catch (Throwable var13) {
+                     var4.addSuppressed(var13);
+                  }
+               } else {
+                  statement.close();
+               }
+            }
+
+         }
+      } catch (SQLException var16) {
+         var16.printStackTrace();
+      }
+
+   }
+
+   public static Integer countFlags(UUID uuid) {
+      int i = 0;
+
+      try {
+         for(ResultSet resultSet = getPlayerFlags(uuid); resultSet.next(); ++i) {
+         }
+      } catch (SQLException var3) {
+         var3.printStackTrace();
+      }
+
+      return i;
+   }
+
+   public static void removePlayerCache(UUID uuid) {
+      String sql = "DELETE FROM player_cache WHERE uuid = ?";
+
+      try {
+         PreparedStatement statement = DatabaseConnection.getConnection().prepareStatement(sql);
+         Throwable var3 = null;
+
+         try {
+            statement.setString(1, uuid.toString());
+            statement.executeUpdate();
+         } catch (Throwable var13) {
+            var3 = var13;
+            throw var13;
+         } finally {
+            if (statement != null) {
+               if (var3 != null) {
+                  try {
+                     statement.close();
+                  } catch (Throwable var12) {
+                     var3.addSuppressed(var12);
+                  }
+               } else {
+                  statement.close();
+               }
+            }
+
+         }
+      } catch (SQLException var15) {
+         var15.printStackTrace();
+      }
+
+   }
+
+   public static boolean hasFlags(UUID u) {
+      try {
+         if (getStringResult("SELECT * FROM player_flags WHERE uuid = ?", u.toString()).next()) {
+            return true;
+         }
+      } catch (SQLException var2) {
+         var2.printStackTrace();
+      }
+
+      return false;
+   }
+
+   public static void addPlayerCache(UUID uuid, String playerName) {
+      String sql = "INSERT INTO player_cache (uuid, player_name) VALUES (?, ?) ON DUPLICATE KEY UPDATE player_name = ?";
+
+      try {
+         PreparedStatement statement = DatabaseConnection.getConnection().prepareStatement(sql);
+         Throwable var4 = null;
+
+         try {
+            statement.setString(1, uuid.toString());
+            statement.setString(2, playerName);
+            statement.setString(3, playerName);
+            statement.execute();
+         } catch (Throwable var14) {
+            var4 = var14;
+            throw var14;
+         } finally {
+            if (statement != null) {
+               if (var4 != null) {
+                  try {
+                     statement.close();
+                  } catch (Throwable var13) {
+                     var4.addSuppressed(var13);
+                  }
+               } else {
+                  statement.close();
+               }
+            }
+
+         }
+      } catch (SQLException var16) {
+         var16.printStackTrace();
+      }
+
+   }
+
+   public static boolean inPlayerCache(UUID uuid) {
+      try {
+         if (getStringResult("SELECT * FROM player_cache WHERE uuid = ?", uuid.toString()).next()) {
+            return true;
+         }
+      } catch (SQLException var2) {
+         var2.printStackTrace();
+      }
+
+      return false;
+   }
+
+   public static String getFlagReason(UUID uuid, int id) {
+      try {
+         ResultSet resultSet = getStringResult("SELECT reason FROM player_flags WHERE uuid = ? AND id = " + id, uuid.toString());
+         if (resultSet.next()) {
+            return resultSet.getString("reason");
+         }
+      } catch (SQLException var3) {
+         var3.printStackTrace();
+      }
+
+      return null;
+   }
+
+   public static ResultSet getPlayerFlags(UUID uuid) throws SQLException {
+      return getStringResult("SELECT * FROM player_flags WHERE uuid = ? ORDER BY id DESC LIMIT " + LiteFlags.getInstance().getConfig().getInt("FlagsHistory.ListLimit"), uuid.toString());
+   }
+
+   public static ResultSet getActiveTime(UUID uuid) throws SQLException {
+      return getStringResult("SELECT expire_time, flagged_by FROM player_flags WHERE uuid = ?", uuid.toString());
+   }
+
+   private static ResultSet getStringResult(String query, String... parameters) throws SQLException {
+      PreparedStatement statement = DatabaseConnection.getConnection().prepareStatement(query);
+
+      for(int i = 1; i < parameters.length + 1; ++i) {
+         statement.setString(i, parameters[i - 1]);
+      }
+
+      return statement.executeQuery();
+   }
+}

src/main/java/com/liteflags/data/database/DatabaseConnection.java

@@ -0,0 +1,47 @@
+package com.liteflags.data.database;
+
+import com.liteflags.LiteFlags;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+
+public class DatabaseConnection {
+   public static DatabaseConnection instance;
+   public Connection connection;
+   public String drivers = LiteFlags.getInstance().getConfig().getString("Database.Drivers");
+   public String ip = LiteFlags.getInstance().getConfig().getString("Database.IP");
+   public String port = LiteFlags.getInstance().getConfig().getString("Database.Port");
+   public String database = LiteFlags.getInstance().getConfig().getString("Database.Database");
+   public String username = LiteFlags.getInstance().getConfig().getString("Database.Username");
+   public String password = LiteFlags.getInstance().getConfig().getString("Database.Password");
+
+   public DatabaseConnection() throws SQLException {
+      instance = this;
+      instance.openConnection();
+      Database.createTables();
+   }
+
+   public void openConnection() throws SQLException {
+      if (this.connection == null || this.connection.isClosed()) {
+         synchronized(this) {
+            if (this.connection == null || this.connection.isClosed()) {
+               this.connection = DriverManager.getConnection("jdbc:" + this.drivers + "://" + this.ip + ":" + this.port + "/" + this.database, this.username, this.password);
+            }
+         }
+      }
+   }
+
+   public static Connection getConnection() {
+      try {
+         instance.openConnection();
+      } catch (SQLException var1) {
+         var1.printStackTrace();
+      }
+
+      return instance.connection;
+   }
+
+   public static void initialize() throws SQLException {
+      instance = new DatabaseConnection();
+   }
+}

src/main/java/com/liteflags/data/database/Methods.java

@@ -0,0 +1,112 @@
+package com.liteflags.data.database;
+
+import com.liteflags.LiteFlags;
+import com.liteflags.util.Utilities;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.concurrent.TimeUnit;
+import org.bukkit.OfflinePlayer;
+
+public class Methods {
+   public static int consoleFlags;
+   public static int staffFlags;
+   public static String flagListLimit = LiteFlags.getInstance().getConfig().getString("ActiveFlags.Limit");
+   public static String playerFlagsHeader;
+
+   public static boolean hasActiveFlags(OfflinePlayer player) {
+      try {
+         ResultSet flag = Database.getActiveTime(player.getUniqueId());
+
+         while(flag.next()) {
+            long expireTime = TimeUnit.SECONDS.toMinutes((long)flag.getInt("expire_time"));
+            long currentTime = TimeUnit.SECONDS.toMinutes(System.currentTimeMillis() / 1000L);
+            int convertedExpireTime = (int)expireTime - (int)currentTime;
+            if (convertedExpireTime >= 0) {
+               return true;
+            }
+
+            if (expireTime == 0L) {
+               return true;
+            }
+         }
+      } catch (SQLException var7) {
+         var7.printStackTrace();
+      }
+
+      return false;
+   }
+
+   public static int getTotalActiveFlags(OfflinePlayer player) {
+      consoleFlags = 0;
+      staffFlags = 0;
+      int i = 0;
+
+      try {
+         ResultSet flag = Database.getActiveTime(player.getUniqueId());
+
+         while(flag.next()) {
+            long expireTime = TimeUnit.SECONDS.toMinutes((long)flag.getInt("expire_time"));
+            long currentTime = TimeUnit.SECONDS.toMinutes(System.currentTimeMillis() / 1000L);
+            int convertedExpireTime = (int)expireTime - (int)currentTime;
+            String s;
+            if (convertedExpireTime >= 0) {
+               ++i;
+               s = flag.getString("flagged_by");
+               if (s.equalsIgnoreCase("console")) {
+                  ++consoleFlags;
+               } else {
+                  ++staffFlags;
+               }
+            } else if (expireTime == 0L) {
+               ++i;
+               s = flag.getString("flagged_by");
+               if (s.equalsIgnoreCase("console")) {
+                  ++consoleFlags;
+               } else {
+                  ++staffFlags;
+               }
+            }
+         }
+      } catch (SQLException var9) {
+         var9.printStackTrace();
+      }
+
+      return i;
+   }
+
+   public static int getActiveConsoleFlags(OfflinePlayer player) {
+      int i = 0;
+
+      try {
+         ResultSet flag = Database.getActiveTime(player.getUniqueId());
+
+         while(flag.next()) {
+            long expireTime = TimeUnit.SECONDS.toMinutes((long)flag.getInt("expire_time"));
+            long currentTime = TimeUnit.SECONDS.toMinutes(System.currentTimeMillis() / 1000L);
+            int convertedExpireTime = (int)expireTime - (int)currentTime;
+            if (convertedExpireTime >= 0) {
+               String s = flag.getString("flagged_by");
+               if (s.equalsIgnoreCase("console")) {
+                  ++i;
+               }
+            }
+         }
+      } catch (SQLException var9) {
+         var9.printStackTrace();
+      }
+
+      return i;
+   }
+
+   public static void getPlayerFlags(OfflinePlayer targetPlayer) {
+   }
+
+   public static int getRandomIntegerBetweenRange(int min, int max) {
+      int x = (int)(Math.random() * (double)(max - min + 1)) + min;
+      return x;
+   }
+
+   static {
+      playerFlagsHeader = Utilities.format(LiteFlags.getInstance().getConfig().getString("Messages.PlayerFlagsHeader").replace("%limit%", flagListLimit));
+   }
+}

src/main/java/com/liteflags/data/maps/MapCache.java

@@ -0,0 +1,11 @@
+package com.liteflags.data.maps;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class MapCache {
+   public static Map<String, String> reauthedPlayers = new HashMap();
+   public static List<String> activeFlags = new ArrayList();
+}

src/main/java/com/liteflags/events/ChatEvent.java

@@ -0,0 +1,58 @@
+package com.liteflags.events;
+
+import com.liteflags.LiteFlags;
+import com.liteflags.data.database.Database;
+import com.liteflags.data.database.Methods;
+import com.liteflags.data.maps.MapCache;
+import com.liteflags.util.Utilities;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.AsyncPlayerChatEvent;
+import org.bukkit.scheduler.BukkitRunnable;
+
+public class ChatEvent implements Listener {
+   private LiteFlags flags;
+
+   public ChatEvent(LiteFlags flags) {
+      this.flags = flags;
+   }
+
+   @EventHandler
+   public void onPlayerChat(AsyncPlayerChatEvent e) {
+      final Player player = e.getPlayer();
+      if (MapCache.reauthedPlayers.containsKey(player.getUniqueId().toString())) {
+         String value = (String)MapCache.reauthedPlayers.get(player.getUniqueId().toString());
+         if (e.getMessage().equals(value)) {
+            e.setCancelled(true);
+            player.sendMessage(Utilities.format(LiteFlags.getInstance().getConfig().getString("Messages.Authenticate_Success")));
+            long time = TimeUnit.SECONDS.toMinutes(System.currentTimeMillis() / 1000L) + 5L;
+            final int min = LiteFlags.getInstance().getConfig().getInt("RandomReauth.MinNumber");
+            final int max = LiteFlags.getInstance().getConfig().getInt("RandomReauth.MaxNumber");
+            new Random();
+            final String timeAmount = LiteFlags.getInstance().getConfig().getString("RandomReauth.TimeFormat");
+            (new BukkitRunnable() {
+               public void run() {
+                  Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), LiteFlags.getInstance().getConfig().getString("Commands.TempAuthSuccess").replace("%player%", player.getName()).replace("%permission%", "liteflags.authentication.success").replace("%expiretime%", Methods.getRandomIntegerBetweenRange(min, max) + timeAmount.substring(0, 1).toLowerCase()));
+               }
+            }).runTask(LiteFlags.getInstance());
+            MapCache.reauthedPlayers.remove(player.getUniqueId().toString());
+            if (Database.inPlayerCache(player.getUniqueId())) {
+               long currentTime = TimeUnit.MILLISECONDS.toMinutes(System.currentTimeMillis());
+               int expireTime = 10080;
+               int conTime = (int)currentTime + expireTime;
+               Database.addFlag(player.getUniqueId(), (long)((int)TimeUnit.MINUTES.toSeconds((long)conTime)), "Possible Hacked Client - Logged out before authenticating.", "Console", "7 Days");
+               Database.removePlayerCache(player.getUniqueId());
+            }
+         } else {
+            e.setCancelled(true);
+            player.sendMessage(Utilities.format(LiteFlags.getInstance().getConfig().getString("Messages.Authenticate_Failed").replace("%code%", (CharSequence)MapCache.reauthedPlayers.get(player.getUniqueId().toString()))));
+            LiteFlags.getInstance().getLogger().info(player.getName() + " tried talking while authenticating: " + e.getMessage());
+         }
+      }
+
+   }
+}

src/main/java/com/liteflags/events/LoginEvent.java

@@ -0,0 +1,43 @@
+package com.liteflags.events;
+
+import com.liteflags.LiteFlags;
+import com.liteflags.auth.Authentication;
+import com.liteflags.data.database.Methods;
+import com.liteflags.data.maps.MapCache;
+import com.liteflags.util.Utilities;
+import java.util.Iterator;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+public class LoginEvent implements Listener {
+   private LiteFlags flags;
+
+   public LoginEvent(LiteFlags flags) {
+      this.flags = flags;
+   }
+
+   @EventHandler
+   public void onPlayerLogin(PlayerJoinEvent e) {
+      Player player = e.getPlayer();
+      if (!player.hasPermission("liteflags.authentication.bypass")) {
+         Authentication.checkAuthStatus(player.getUniqueId());
+      }
+
+      if (Methods.hasActiveFlags(player)) {
+         MapCache.activeFlags.add(player.getName());
+         Iterator var3 = Bukkit.getOnlinePlayers().iterator();
+
+         while(var3.hasNext()) {
+            Player staff = (Player)var3.next();
+            if (staff.hasPermission("liteflags.alertflags") && !LiteFlags.getInstance().getConfig().getString("Messages.AlertActiveFlags").equalsIgnoreCase("disablethis")) {
+               int activeTotalFlags = Methods.getTotalActiveFlags(player);
+               Utilities.sendStaffHoverMessage(player, staff, Utilities.format(LiteFlags.getInstance().getConfig().getString("Messages.AlertActiveFlags").replace("%player%", player.getName()).replace("%totalactflags%", "" + activeTotalFlags).replace("%consoleFlags%", "" + Methods.consoleFlags).replace("%staffFlags%", "" + Methods.staffFlags)));
+            }
+         }
+      }
+
+   }
+}

src/main/java/com/liteflags/events/LogoutEvent.java

@@ -0,0 +1,36 @@
+package com.liteflags.events;
+
+import com.liteflags.LiteFlags;
+import com.liteflags.auth.AuthTimer;
+import com.liteflags.data.database.Database;
+import com.liteflags.data.maps.MapCache;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+public class LogoutEvent implements Listener {
+   private LiteFlags flags;
+
+   public LogoutEvent(LiteFlags flags) {
+      this.flags = flags;
+   }
+
+   @EventHandler
+   public void onPlayerLogout(PlayerQuitEvent e) {
+      Player player = e.getPlayer();
+      if (AuthTimer.taskID.containsKey(player.getUniqueId())) {
+         AuthTimer.endTask(player);
+      }
+
+      if (MapCache.reauthedPlayers.containsKey(player.getUniqueId().toString())) {
+         Database.addPlayerCache(player.getUniqueId(), player.getName());
+         MapCache.reauthedPlayers.remove(player.getUniqueId().toString());
+      }
+
+      if (MapCache.activeFlags.contains(player.getName())) {
+         MapCache.activeFlags.remove(player.getName());
+      }
+
+   }
+}

src/main/java/com/liteflags/events/MoveEvent.java

@@ -0,0 +1,27 @@
+package com.liteflags.events;
+
+import com.liteflags.LiteFlags;
+import com.liteflags.data.maps.MapCache;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerMoveEvent;
+
+public class MoveEvent implements Listener {
+   private LiteFlags flags;
+
+   public MoveEvent(LiteFlags flags) {
+      this.flags = flags;
+   }
+
+   @EventHandler
+   public void onPlayerMove(PlayerMoveEvent e) {
+      Player player = e.getPlayer();
+      if (MapCache.reauthedPlayers.containsKey(player.getUniqueId().toString())) {
+         e.setCancelled(true);
+      } else {
+         e.setCancelled(false);
+      }
+
+   }
+}

src/main/java/com/liteflags/util/Utilities.java

@@ -0,0 +1,95 @@
+package com.liteflags.util;
+
+import java.util.concurrent.TimeUnit;
+import net.md_5.bungee.api.ChatColor;
+import net.md_5.bungee.api.chat.ClickEvent;
+import net.md_5.bungee.api.chat.ComponentBuilder;
+import net.md_5.bungee.api.chat.HoverEvent;
+import net.md_5.bungee.api.chat.TextComponent;
+import net.md_5.bungee.api.chat.HoverEvent.Action;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class Utilities {
+   public static String convertTime(int time) {
+      int days = (int)TimeUnit.MINUTES.toDays((long)time);
+      int hours = (int)(TimeUnit.MINUTES.toHours((long)time) - TimeUnit.DAYS.toHours((long)days));
+      int minutes = (int)(TimeUnit.MINUTES.toMinutes((long)time) - TimeUnit.HOURS.toMinutes((long)hours) - TimeUnit.DAYS.toMinutes((long)days));
+      String d = days + " day";
+      String h = hours + " hour";
+      String m = minutes + " minute";
+      String c = ", ";
+      if (days == 0) {
+         if (hours == 0) {
+            return minutes == 1 ? m : m + "s";
+         } else if (hours == 1) {
+            if (minutes == 1) {
+               return h + c + m;
+            } else {
+               return minutes == 0 ? h : h + c + m + "s";
+            }
+         } else if (minutes == 1) {
+            return h + "s" + c + m;
+         } else {
+            return minutes == 0 ? h + "s" : h + "s" + c + m + "s";
+         }
+      } else if (days == 1) {
+         if (hours == 1) {
+            if (minutes == 1) {
+               return d + c + h + c + m;
+            } else {
+               return minutes == 0 ? d + c + h : d + c + h + c + m + "s";
+            }
+         } else if (minutes == 1) {
+            return hours == 0 ? d + c + m : d + c + h + "s" + c + m;
+         } else if (minutes == 0) {
+            return hours == 0 ? d : d + c + h + "s";
+         } else {
+            return hours == 0 ? d + c + m + "s" : d + c + h + "s" + c + m + "s";
+         }
+      } else if (hours == 1) {
+         if (minutes == 1) {
+            return d + "s" + c + h + c + m;
+         } else {
+            return minutes == 0 ? d + "s" + c + h : d + "s" + c + h + c + m + "s";
+         }
+      } else if (minutes == 1) {
+         return hours == 0 ? d + "s" + c + m : d + "s" + c + h + "s" + c + m;
+      } else if (minutes == 0) {
+         return hours == 0 ? d + "s" : d + "s" + c + h + "s";
+      } else {
+         return hours == 0 ? d + "s" + c + m + "s" : d + "s" + c + h + "s" + c + m + "s";
+      }
+   }
+
+   public static String format(String m) {
+      return ChatColor.translateAlternateColorCodes('&', m);
+   }
+
+   public static void sendStaffHoverMessage(OfflinePlayer targetPlayer, Player staffPlayer, String mainString) {
+      TextComponent mainComponent = new TextComponent(mainString);
+      mainComponent.setHoverEvent(new HoverEvent(Action.SHOW_TEXT, (new ComponentBuilder(ChatColor.GRAY + "Click to view " + targetPlayer.getName() + "'s flags")).create()));
+      mainComponent.setClickEvent(new ClickEvent(net.md_5.bungee.api.chat.ClickEvent.Action.RUN_COMMAND, "/flaglist " + targetPlayer.getName()));
+      staffPlayer.spigot().sendMessage(mainComponent);
+   }
+
+   public static void sendFlagConfirmMessage(CommandSender sender, OfflinePlayer targetPlayer, int id, String flagReason) {
+      TextComponent mainComponent = new TextComponent("Are you sure you want to remove the flag '" + flagReason + "' from " + ChatColor.YELLOW + targetPlayer.getName() + "'s" + ChatColor.GRAY + " flag history? ");
+      mainComponent.setColor(ChatColor.GRAY);
+      TextComponent confirmButton = new TextComponent("[Confirm]");
+      confirmButton.setColor(ChatColor.GREEN);
+      confirmButton.setHoverEvent(new HoverEvent(Action.SHOW_TEXT, (new ComponentBuilder(ChatColor.GREEN + "Click to confirm")).create()));
+      confirmButton.setClickEvent(new ClickEvent(net.md_5.bungee.api.chat.ClickEvent.Action.RUN_COMMAND, "/flag remove " + id + " " + targetPlayer.getName() + " -c"));
+      mainComponent.addExtra(confirmButton);
+      sender.spigot().sendMessage(mainComponent);
+   }
+
+   public static TextComponent textComponent(TextComponent component) {
+      return component;
+   }
+
+   public static void sendMessage(Player player, TextComponent component) {
+      player.spigot().sendMessage(component);
+   }
+}

src/main/resources/config.yml

@@ -0,0 +1,99 @@
+###################################################################
+
+#                          #######
+#        #  #####  ######  #        #         ##     ####    ####
+#        #    #    #       #        #        #  #   #    #  #
+#        #    #    #####   #####    #       #    #  #        ####
+#        #    #    #       #        #       ######  #  ###       #
+#        #    #    #       #        #       #    #  #    #  #    #
+#######  #    #    ######  #        ######  #    #   ####    ####
+
+#                         By - MrPixxima
+
+###################################################################
+
+Database:
+  IP: localhost
+  Port: 3306
+  Database: liteflags
+  Username: root
+  Password: root
+  Drivers: mysql
+
+#Flag Configuration
+
+# The amount of active flags a player can have at once.
+ActiveFlags:
+  Limit: 5
+
+  # It will show the last 5 flags a player has when the command /flag list <player>
+  # 0 will set it to show all flags.
+FlagsHistory:
+  ListLimit: 10
+
+#Authentication Configuration
+
+# This will enable a random time set for a player after they authenticate.
+# It will set a random number between a min and max number set in the configuration.
+RandomReauth:
+
+  # This will set the reuth time in (Minutes, Hours, Days)
+  TimeFormat: Days
+
+  # It will choose a random number from these 2 numbers and it will
+  # set their reauth to that random number and how long with Days, Hour, Minutes above. (Ex: 7 Days)
+  MinNumber: 14
+  MaxNumber: 30
+
+# Commands executed when a player authenticates successfully
+Commands:
+
+  # The permission a player gets for x amount of time.
+  # This command is only executed when RandomReuth is enabled.
+  TempAuthSuccess: "lp user %player% permission settemp %permission% true %expiretime%"
+
+# Configurable Messages
+Messages:
+
+  # Key:
+  # %player% - Returns the given player name
+  # %staff% - Return the given staff member name. (Only works in PlayerFlags list)
+  # %reason% - Returns the reason why a player was flagged
+  # %flagtime% - Returns the time when the flag was applied to the given player
+  # %active% - Displayes the Active and Expired strings depending on if the flags are active/expired.
+  # %expiretime% - Returns when a flag will expire if it is active.
+  # %code% - Returns the code the player needs type to authenticate
+
+
+  # The message it sends to staff when a player has active flags
+  # To disable this set the string to "disablethis"
+  AlertActiveFlags: "&7%player% has &c%totalactflags%&7 active flags!"
+
+  # Flags messages
+  PlayerFlagsHeader: "&7&m------&6 Flags (Limit %limit%) &7&m------"
+
+  PlayerFlagsBody:
+    - "%nl%"
+    - "&7&m----&7 %flagtime% ago &7&m----"
+    - "&8%player% was &eflagged&8 for %flaglength% by &e%staff%"
+    - "&8Reason: &6%reason% %active%"
+
+  # The string for %active% if the flag is active - Leave blank to disable.
+  ActiveFlags: "&f[&aActive&f]"
+
+  # The string for %active% if the flag is expired - Leave blank to disable.
+  ExpiredFlags: "&f[&cExpired&f]"
+
+  NoPermission: "&cYou do not have permission to do that."
+  ActiveFlagsLimit: "&e%player% &7has reached the active flags limit."
+  FlaggedPlayer: "&6* %staff% has flagged %player% for (%flaglength%) - Reason: %reason%"
+
+  # Authenticate messages
+  Authenticate: "&7You need to authenticate! Type &6%code%&7 in chat to authenticate. (CaSe SeNsiTiVe)"
+  Authenticate_Failed: "&7You need to authenticate! Type &6%code%&7 in chat to authenticate. (CaSe SeNsiTiVe)"
+  Authenticate_Success: "&7You have authed! You can now play!"
+
+  # How often should the authenicate message show up on a players screen (In seconds)
+Authenticate_Timer: 10
+  # The command that broadcast the authenticate message on a players screen.
+Authenticate_Timer_Command: "tm message %player% You need to authenticate! Type %code% in chat to authenticate. (CaSe SeNsiTiVe)"

src/main/resources/plugin.yml

@@ -0,0 +1,9 @@
+name: LiteFlags
+main: com.liteflags.LiteFlags
+version: 0.5
+commands:
+  flag:
+    description: Flags a player!
+  flaglist:
+    description: Shows players flags!
+    aliases: fl