commit 7817301148d27967c93a47c45e0c7a7f45628ec1 Author: rattatwinko Date: Sat May 10 19:16:33 2025 +0200 Easyadmin initial diff --git a/.gitea/workflows/maven_build.yaml b/.gitea/workflows/maven_build.yaml new file mode 100644 index 0000000..9f02764 --- /dev/null +++ b/.gitea/workflows/maven_build.yaml @@ -0,0 +1,55 @@ +name: Maven Build + +on: + push: + branches: [ main, master, dev ] + pull_request: + branches: [ main, master ] + workflow_dispatch: + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Set up JDK 21 + uses: actions/setup-java@v3 + with: + distribution: 'temurin' + java-version: '21' + cache: 'maven' + + - name: Install Maven + run: | + if ! command -v mvn &> /dev/null; then + echo "Maven not found, installing..." + sudo apt-get update + sudo apt-get install -y maven + fi + mvn --version + + - name: Debug Info + run: | + echo "Current workspace directory: $GITHUB_WORKSPACE" + echo "Current directory: $(pwd)" + echo "Project structure:" + find . -type f -name "*.kt" | sort + find . -type f -name "pom.xml" + echo "Maven version: $(mvn --version)" + + - name: Build easyadmin (easyadmin) + run: | + echo "Building easyadmin" + echo "Current directory: $(pwd)" + # Run Maven build directly using the POM file path + mvn -B clean package -f "$GITHUB_WORKSPACE/pom.xml" -Dmaven.compiler.failOnError=true + + - name: Upload easyadmin artifact + uses: actions/upload-artifact@v3 + with: + name: easyadmin + path: target/easyadmin-*.jar + if-no-files-found: error diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..4788b4b --- /dev/null +++ b/.gitignore @@ -0,0 +1,113 @@ +# User-specific stuff +.idea/ + +*.iml +*.ipr +*.iws + +# IntelliJ +out/ + +# Compiled class file +*.class + +# Log file +*.log + +# BlueJ files +*.ctxt + +# 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* + +*~ + +# temporary files which can be created if a process still has a handle open of a deleted file +.fuse_hidden* + +# KDE directory preferences +.directory + +# Linux trash folder which might appear on any partition or disk +.Trash-* + +# .nfs files are created when an open file is removed but is still being accessed +.nfs* + +# General +.DS_Store +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +# Windows thumbnail cache files +Thumbs.db +Thumbs.db:encryptable +ehthumbs.db +ehthumbs_vista.db + +# Dump file +*.stackdump + +# Folder config file +[Dd]esktop.ini + +# Recycle Bin used on file shares +$RECYCLE.BIN/ + +# Windows Installer files +*.cab +*.msi +*.msix +*.msm +*.msp + +# Windows shortcuts +*.lnk + +target/ + +pom.xml.tag +pom.xml.releaseBackup +pom.xml.versionsBackup +pom.xml.next + +release.properties +dependency-reduced-pom.xml +buildNumber.properties +.mvn/timing.properties +.mvn/wrapper/maven-wrapper.jar +.flattened-pom.xml + +# Common working directory +run/ diff --git a/build.sh b/build.sh new file mode 100755 index 0000000..5520b77 --- /dev/null +++ b/build.sh @@ -0,0 +1,10 @@ +#!/bin/bash +# Direct build script for Maven project + +echo "Current directory: $(pwd)" +echo "Building project with Maven..." + +# Run Maven build using the exact pom.xml location +mvn clean package -f "$(pwd)/pom.xml" + +echo "Build complete. JAR file should be in target/ directory." diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..a8606d1 --- /dev/null +++ b/pom.xml @@ -0,0 +1,87 @@ + + + 4.0.0 + + org.easyadmin + easyadmin + 1.0-SNAPSHOT + jar + + easyadmin + + + 21 + 2.2.0-Beta2 + UTF-8 + + + + clean package + ${project.basedir}/src/main/kotlin + + + org.jetbrains.kotlin + kotlin-maven-plugin + ${kotlin.version} + + + compile + compile + + compile + + + + + ${java.version} + + + + org.apache.maven.plugins + maven-shade-plugin + 3.5.3 + + + package + + shade + + + + + + + + src/main/resources + true + + + + + + + papermc-repo + https://repo.papermc.io/repository/maven-public/ + + + sonatype + https://oss.sonatype.org/content/groups/public/ + + + + + + io.papermc.paper + paper-api + 1.21.5-R0.1-SNAPSHOT + provided + + + org.jetbrains.kotlin + kotlin-stdlib-jdk8 + ${kotlin.version} + + + diff --git a/pommer.py b/pommer.py new file mode 100644 index 0000000..ae68fd3 --- /dev/null +++ b/pommer.py @@ -0,0 +1,274 @@ +#!/usr/bin/env python3 +import os +import xml.etree.ElementTree as ET +import re +from pathlib import Path +import argparse +import glob + + +def parse_pom_xml(pom_path): + """ + Parse a pom.xml file and extract relevant information + """ + try: + print(f"Parsing POM file: {pom_path}") + + # Register the default namespace + ET.register_namespace('', "http://maven.apache.org/POM/4.0.0") + + # Parse the XML file + tree = ET.parse(pom_path) + root = tree.getroot() + + # Define namespace for easier XPath queries + ns = {'mvn': "http://maven.apache.org/POM/4.0.0"} + + # Extract project info + artifact_id = root.find('./mvn:artifactId', ns).text + group_id = root.find('./mvn:groupId', ns).text if root.find('./mvn:groupId', ns) is not None else "unknown" + version = root.find('./mvn:version', ns).text if root.find('./mvn:version', ns) is not None else "unknown" + name = root.find('./mvn:name', ns).text if root.find('./mvn:name', ns) is not None else artifact_id + + # Extract Java version + java_version_elem = root.find('./mvn:properties/mvn:java.version', ns) + java_version = java_version_elem.text if java_version_elem is not None else "17" # Default to Java 17 if not specified + + # Extract packaging type (default to jar if not specified) + packaging = root.find('./mvn:packaging', ns) + packaging = packaging.text if packaging is not None else "jar" + + # Check if Kotlin is used + kotlin_version_elem = root.find('./mvn:properties/mvn:kotlin.version', ns) + kotlin_version = kotlin_version_elem.text if kotlin_version_elem is not None else None + + # Check for Kotlin plugin or dependency + kotlin_plugin = None + kotlin_dep = None + + # Check for Kotlin plugin + plugins = root.findall('.//mvn:plugin', ns) + for plugin in plugins: + plugin_group = plugin.find('./mvn:groupId', ns) + if plugin_group is not None and plugin_group.text == 'org.jetbrains.kotlin': + kotlin_plugin = plugin + break + + # Check for Kotlin dependency + deps = root.findall('.//mvn:dependency', ns) + for dep in deps: + dep_group = dep.find('./mvn:groupId', ns) + dep_artifact = dep.find('./mvn:artifactId', ns) + if (dep_group is not None and dep_group.text == 'org.jetbrains.kotlin' and + dep_artifact is not None and 'kotlin-stdlib' in dep_artifact.text): + kotlin_dep = dep + break + + # Determine if this is a Kotlin project + is_kotlin = kotlin_version is not None or kotlin_plugin is not None or kotlin_dep is not None + + # Check for source directories + source_dir = None + source_dirs = root.findall('.//mvn:sourceDirectory', ns) + if source_dirs: + source_dir = source_dirs[0].text + + # Check for default goal (to use the same command as IntelliJ) + default_goal = None + default_goal_elem = root.find('./mvn:build/mvn:defaultGoal', ns) + if default_goal_elem is not None: + default_goal = default_goal_elem.text + + return { + "artifact_id": artifact_id, + "group_id": group_id, + "version": version, + "name": name, + "java_version": java_version, + "packaging": packaging, + "is_kotlin": is_kotlin, + "kotlin_version": kotlin_version, + "source_dir": source_dir, + "default_goal": default_goal, + "pom_path": pom_path + } + except Exception as e: + print(f"Error parsing {pom_path}: {e}") + return None + + +def generate_gitea_workflow(pom_infos): + """ + Generate a Gitea workflow YAML file based on multiple POM information + """ + if not pom_infos: + print("No valid POM files found") + return None + + # Get the highest Java version required + java_version = max([info["java_version"] for info in pom_infos]) + + # Check if any project uses Kotlin + uses_kotlin = any(info["is_kotlin"] for info in pom_infos) + + # Kotlin version (if any) + kotlin_version = None + for info in pom_infos: + if info["kotlin_version"]: + kotlin_version = info["kotlin_version"] + break + + # Construct the workflow content + workflow_content = f"""name: Maven Build + +on: + push: + branches: [ main, master, dev ] + pull_request: + branches: [ main, master ] + workflow_dispatch: + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Set up JDK {java_version} + uses: actions/setup-java@v3 + with: + distribution: 'temurin' + java-version: '{java_version}' + cache: 'maven' + + - name: Install Maven + run: | + if ! command -v mvn &> /dev/null; then + echo "Maven not found, installing..." + sudo apt-get update + sudo apt-get install -y maven + fi + mvn --version + + - name: Debug Info + run: | + echo "Current workspace directory: $GITHUB_WORKSPACE" + echo "Current directory: $(pwd)" + echo "Project structure:" + find . -type f -name "*.kt" | sort + find . -type f -name "pom.xml" + echo "Maven version: $(mvn --version)" +""" + + # Add individual build steps for each POM + for i, info in enumerate(pom_infos): + # Determine the Maven command to use (same as the default goal if specified) + maven_command = "clean package" + if info["default_goal"]: + maven_command = info["default_goal"] + + workflow_content += f""" + - name: Build {info["name"]} ({info["artifact_id"]}) + run: | + echo "Building {info["artifact_id"]}" + echo "Current directory: $(pwd)" + # Run Maven build directly using the POM file path + mvn -B {maven_command} -f "$GITHUB_WORKSPACE/pom.xml" -Dmaven.compiler.failOnError=true +""" + + # Add artifact upload step + workflow_content += f""" + - name: Upload {info["artifact_id"]} artifact + uses: actions/upload-artifact@v3 + with: + name: {info["artifact_id"]} + path: target/{info['artifact_id']}-*.jar + if-no-files-found: error +""" + + return workflow_content + + +def find_pom_files(base_dir="."): + """Find all pom.xml files in the given directory and subdirectories""" + return glob.glob(f"{base_dir}/**/pom.xml", recursive=True) + + +def main(): + parser = argparse.ArgumentParser(description='Generate Gitea workflow for Maven/Kotlin projects') + parser.add_argument('--dir', '-d', default='.', help='Base directory to search for pom.xml files') + parser.add_argument('--specific-pom', '-p', help='Path to a specific pom.xml file to process') + args = parser.parse_args() + + pom_files = [] + if args.specific_pom: + pom_files = [args.specific_pom] + else: + pom_files = find_pom_files(args.dir) + + if not pom_files: + print(f"No pom.xml files found in {args.dir}") + return + + print(f"Found {len(pom_files)} pom.xml files") + + # Parse all POM files + pom_infos = [] + for pom_file in pom_files: + info = parse_pom_xml(pom_file) + if info: + pom_infos.append(info) + + if not pom_infos: + print("No valid POM files could be parsed") + return + + # Generate the workflow content + workflow_content = generate_gitea_workflow(pom_infos) + + if not workflow_content: + return + + # Create the .gitea/workflows directory if it doesn't exist + workflow_dir = Path(".gitea/workflows") + workflow_dir.mkdir(parents=True, exist_ok=True) + + # Write the workflow file + workflow_file = workflow_dir / "maven_build.yaml" + with open(workflow_file, "w") as f: + f.write(workflow_content) + + print(f"Gitea workflow generated at: {workflow_file}") + print(f"This workflow will build {len(pom_infos)} Maven projects") + + # Print summary of detected projects + print("\nDetected projects:") + for info in pom_infos: + kotlin_info = "with Kotlin" if info["is_kotlin"] else "Java only" + build_command = info["default_goal"] if info["default_goal"] else "clean package" + print( + f"- {info['name']} ({info['artifact_id']}): {kotlin_info}, Java {info['java_version']}, build: {build_command}") + + # Create a simple direct build script as fallback + with open("build.sh", "w") as f: + f.write("""#!/bin/bash +# Direct build script for Maven project + +echo "Current directory: $(pwd)" +echo "Building project with Maven..." + +# Run Maven build using the exact pom.xml location +mvn clean package -f "$(pwd)/pom.xml" + +echo "Build complete. JAR file should be in target/ directory." +""") + + # Make it executable + os.chmod("build.sh", 0o755) + print(f"Simple build script generated at: build.sh") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/main/kotlin/org/easyadmin/easyadmin/Easyadmin.kt b/src/main/kotlin/org/easyadmin/easyadmin/Easyadmin.kt new file mode 100644 index 0000000..e719547 --- /dev/null +++ b/src/main/kotlin/org/easyadmin/easyadmin/Easyadmin.kt @@ -0,0 +1,286 @@ +@file:Suppress("DEPRECATION") + +package org.easyadmin.easyadmin + +import org.bukkit.Bukkit +import org.bukkit.ChatColor +import org.bukkit.Material +import org.bukkit.command.Command +import org.bukkit.command.CommandSender +import org.bukkit.entity.Player +import org.bukkit.event.EventHandler +import org.bukkit.event.Listener +import org.bukkit.event.inventory.InventoryClickEvent +import org.bukkit.inventory.ItemStack +import org.bukkit.inventory.meta.ItemMeta // Is very much needed but here is a error! +import org.bukkit.plugin.java.JavaPlugin + +class Easyadmin : JavaPlugin(), Listener { + private val menuName = "${ChatColor.DARK_PURPLE}${ChatColor.BOLD}EasyAdmin" + + override fun onEnable() { + // Register events and commands + server.pluginManager.registerEvents(this, this) + logger.info("${ChatColor.GREEN}EasyAdmin plugin enabled!") + } + + override fun onDisable() { + logger.info("${ChatColor.RED}EasyAdmin plugin disabled!") + } + + override fun onCommand(sender: CommandSender, command: Command, label: String, args: Array): Boolean { + if (sender !is Player) { + sender.sendMessage("${ChatColor.RED}This command can only be used by players!") + return true + } + + if (command.name.equals("easyadmin", ignoreCase = true)) { + if (!sender.hasPermission("easyadmin.use")) { + sender.sendMessage("${ChatColor.RED}You don't have permission to use this command!") + return true + } + + openAdminMenu(sender) + return true + } + + return false + } + + private fun openAdminMenu(player: Player) { + val inventory = Bukkit.createInventory(null, 27, menuName) + + // Time control + inventory.setItem(10, createGuiItem(Material.CLOCK, "${ChatColor.YELLOW}Time Control", + "${ChatColor.GRAY}Click to cycle time")) + + // Weather control + inventory.setItem(11, createGuiItem(Material.WATER_BUCKET, "${ChatColor.BLUE}Weather Control", + "${ChatColor.GRAY}Click to cycle weather")) + + // Kick all players + inventory.setItem(12, createGuiItem(Material.IRON_BOOTS, "${ChatColor.RED}Kick All", + "${ChatColor.GRAY}Kick all non-admin players")) + + // Player management + inventory.setItem(13, createGuiItem(Material.PLAYER_HEAD, "${ChatColor.GREEN}Player Management", + "${ChatColor.GRAY}Manage online players")) + + // World management + inventory.setItem(14, createGuiItem(Material.GRASS_BLOCK, "${ChatColor.GOLD}World Management", + "${ChatColor.GRAY}Manage worlds")) + + // Server properties + inventory.setItem(15, createGuiItem(Material.COMMAND_BLOCK, "${ChatColor.LIGHT_PURPLE}Server Settings", + "${ChatColor.GRAY}View and modify server properties")) + + // Plugin management + inventory.setItem(16, createGuiItem(Material.BOOK, "${ChatColor.AQUA}Plugin Management", + "${ChatColor.GRAY}Enable/disable plugins")) + + player.openInventory(inventory) + } + + private fun createGuiItem(material: Material, name: String, vararg lore: String): ItemStack { + val item = ItemStack(material, 1) + val meta = item.itemMeta!! + + meta.setDisplayName(name) + + if (lore.isNotEmpty()) { + meta.lore = lore.toList() + } + + item.itemMeta = meta + return item + } + + @EventHandler + fun onInventoryClick(event: InventoryClickEvent) { + if (event.view.title != menuName) return + + event.isCancelled = true + + val player = event.whoClicked as Player + if (!player.hasPermission("easyadmin.use")) return + + when (event.slot) { + 10 -> handleTimeControl(player) + 11 -> handleWeatherControl(player) + 12 -> handleKickAll(player) + 13 -> openPlayerManagement(player) + 14 -> openWorldManagement(player) + 15 -> openServerSettings(player) + 16 -> openPluginManagement(player) + } + } + + private fun handleTimeControl(player: Player) { + val world = player.world + when (world.time) { + in 0..6000 -> world.time = 6000 // Set to noon + in 6001..12000 -> world.time = 12000 // Set to sunset + in 12001..18000 -> world.time = 18000 // Set to midnight + else -> world.time = 0 // Set to sunrise + } + player.sendMessage("${ChatColor.GREEN}Time changed in ${world.name}!") + } + + private fun handleWeatherControl(player: Player) { + val world = player.world + when { + world.isThundering -> { + world.setStorm(false) + world.isThundering = false + player.sendMessage("${ChatColor.GREEN}Weather set to clear in ${world.name}!") + } + world.hasStorm() -> { + world.setStorm(true) + world.isThundering = true + player.sendMessage("${ChatColor.GREEN}Weather set to thunderstorm in ${world.name}!") + } + else -> { + world.setStorm(true) + player.sendMessage("${ChatColor.GREEN}Weather set to rain in ${world.name}!") + } + } + } + + private fun handleKickAll(player: Player) { + val kickMessage = "${ChatColor.RED}Server is being maintained by an administrator." + var kickCount = 0 + + for (onlinePlayer in Bukkit.getOnlinePlayers()) { + if (!onlinePlayer.hasPermission("easyadmin.exempt") && onlinePlayer != player) { + onlinePlayer.kickPlayer(kickMessage) + kickCount++ + } + } + + player.sendMessage("${ChatColor.GREEN}Kicked $kickCount players from the server.") + } + + private fun openPlayerManagement(player: Player) { + val inventory = Bukkit.createInventory(null, 54, "${ChatColor.GREEN}${ChatColor.BOLD}Player Management") + + var slot = 0 + for (onlinePlayer in Bukkit.getOnlinePlayers()) { + if (slot >= 54) break + + val playerHead = ItemStack(Material.PLAYER_HEAD, 1) + val meta = playerHead.itemMeta!! + meta.setDisplayName("${ChatColor.YELLOW}${onlinePlayer.name}") + + val lore = mutableListOf() + lore.add("${ChatColor.GRAY}Health: ${ChatColor.RED}${onlinePlayer.health}") + lore.add("${ChatColor.GRAY}Gamemode: ${ChatColor.GOLD}${onlinePlayer.gameMode}") + lore.add("${ChatColor.GRAY}World: ${ChatColor.GREEN}${onlinePlayer.world.name}") + lore.add("") + lore.add("${ChatColor.GREEN}Left-click: ${ChatColor.WHITE}Teleport to player") + lore.add("${ChatColor.RED}Right-click: ${ChatColor.WHITE}More options") + + meta.lore = lore + playerHead.itemMeta = meta + + inventory.setItem(slot, playerHead) + slot++ + } + + player.openInventory(inventory) + } + + private fun openWorldManagement(player: Player) { + val inventory = Bukkit.createInventory(null, 27, "${ChatColor.GOLD}${ChatColor.BOLD}World Management") + + var slot = 0 + for (world in Bukkit.getWorlds()) { + if (slot >= 27) break + + val worldIcon = ItemStack(Material.GRASS_BLOCK, 1) + if (world.environment == org.bukkit.World.Environment.NETHER) { + worldIcon.type = Material.NETHERRACK + } else if (world.environment == org.bukkit.World.Environment.THE_END) { + worldIcon.type = Material.END_STONE + } + + val meta = worldIcon.itemMeta!! + meta.setDisplayName("${ChatColor.YELLOW}${world.name}") + + val lore = mutableListOf() + lore.add("${ChatColor.GRAY}Players: ${ChatColor.WHITE}${world.players.size}") + lore.add("${ChatColor.GRAY}Time: ${ChatColor.WHITE}${world.time}") + lore.add("${ChatColor.GRAY}Weather: ${ChatColor.WHITE}${if (world.hasStorm()) "Raining" else "Clear"}") + lore.add("") + lore.add("${ChatColor.GREEN}Click: ${ChatColor.WHITE}Teleport to world spawn") + + meta.lore = lore + worldIcon.itemMeta = meta + + inventory.setItem(slot, worldIcon) + slot++ + } + + player.openInventory(inventory) + } + + private fun openServerSettings(player: Player) { + val inventory = Bukkit.createInventory(null, 27, "${ChatColor.LIGHT_PURPLE}${ChatColor.BOLD}Server Settings") + + // Difficulty setting + inventory.setItem(10, createGuiItem(Material.ZOMBIE_HEAD, "${ChatColor.RED}Difficulty", + "${ChatColor.GRAY}Current: ${ChatColor.WHITE}${player.world.difficulty}", + "${ChatColor.GRAY}Click to cycle")) + + // Gamemode setting + inventory.setItem(11, createGuiItem(Material.DIAMOND_SWORD, "${ChatColor.BLUE}Default Gamemode", + "${ChatColor.GRAY}Current: ${ChatColor.WHITE}${Bukkit.getDefaultGameMode()}", + "${ChatColor.GRAY}Click to cycle")) + + // Toggle mob spawning + inventory.setItem(12, createGuiItem(Material.SPAWNER, "${ChatColor.GREEN}Mob Spawning", + "${ChatColor.GRAY}Click to toggle mob spawning")) + + // PVP toggle + inventory.setItem(13, createGuiItem(Material.GOLDEN_SWORD, "${ChatColor.GOLD}PVP", + "${ChatColor.GRAY}Click to toggle PVP")) + + // Whitelist + inventory.setItem(14, createGuiItem(Material.PAPER, "${ChatColor.WHITE}Whitelist", + "${ChatColor.GRAY}Click to toggle whitelist")) + + // Save all worlds + inventory.setItem(15, createGuiItem(Material.FLOWER_POT, "${ChatColor.AQUA}Save All", + "${ChatColor.GRAY}Click to save all worlds")) + + // Restart server (placeholder) + inventory.setItem(16, createGuiItem(Material.REDSTONE_BLOCK, "${ChatColor.DARK_RED}Restart Server", + "${ChatColor.GRAY}Click to restart server", + "${ChatColor.RED}This requires additional setup")) + + player.openInventory(inventory) + } + + private fun openPluginManagement(player: Player) { + val inventory = Bukkit.createInventory(null, 54, "${ChatColor.AQUA}${ChatColor.BOLD}Plugin Management") + + var slot = 0 + for (plugin in Bukkit.getPluginManager().plugins) { + if (slot >= 54) break + + val enabled = plugin.isEnabled + val material = if (enabled) Material.LIME_DYE else Material.GRAY_DYE + + val pluginItem = createGuiItem(material, + "${if (enabled) ChatColor.GREEN else ChatColor.RED}${plugin.name}", + "${ChatColor.GRAY}Version: ${ChatColor.WHITE}${plugin.description.version}", + "${ChatColor.GRAY}Status: ${if (enabled) "${ChatColor.GREEN}Enabled" else "${ChatColor.RED}Disabled"}", + "", + "${ChatColor.YELLOW}Click to ${if (enabled) "disable" else "enable"}") + + inventory.setItem(slot, pluginItem) + slot++ + } + + player.openInventory(inventory) + } +} diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml new file mode 100644 index 0000000..f19c053 --- /dev/null +++ b/src/main/resources/plugin.yml @@ -0,0 +1,22 @@ +name: EasyAdmin +version: 1.0-SNAPSHOT +main: org.easyadmin.easyadmin.Easyadmin +api-version: '1.21' +author: rattatwinko +description: A minimal yet powerful admin GUI for Minecraft servers + +commands: + easyadmin: + description: Opens the EasyAdmin GUI + usage: /easyadmin + aliases: [ea, admin, adminpanel] + permission: easyadmin.use + permission-message: You don't have permission to use this command! + +permissions: + easyadmin.use: + description: Allows access to the EasyAdmin GUI + default: op + easyadmin.exempt: + description: Exempts players from being kicked by the kick all function + default: op \ No newline at end of file