下面列出了怎么用org.bukkit.command.ConsoleCommandSender的API类实例代码及写法,或者点击链接到github查看源代码。
@Test
public void shouldStopTaskAndInformConsoleUser() {
// given
Set<String> names = newHashSet("name1", "name2");
PurgeTask task = new PurgeTask(purgeService, permissionsManager, null, names, new OfflinePlayer[0]);
BukkitTask bukkitTask = mock(BukkitTask.class);
given(bukkitTask.getTaskId()).willReturn(10049);
ReflectionTestUtils.setField(BukkitRunnable.class, task, "task", bukkitTask);
Server server = mock(Server.class);
BukkitScheduler scheduler = mock(BukkitScheduler.class);
given(server.getScheduler()).willReturn(scheduler);
ReflectionTestUtils.setField(Bukkit.class, null, "server", server);
ConsoleCommandSender consoleSender = mock(ConsoleCommandSender.class);
given(server.getConsoleSender()).willReturn(consoleSender);
task.run(); // Run for the first time -> results in empty names list
// when
task.run();
// then
verify(scheduler).cancelTask(task.getTaskId());
verify(consoleSender).sendMessage(argThat(containsString("Database has been purged successfully")));
}
@Override
public void onCommand(
@NotNull CommandSender sender, @NotNull String commandLabel, @NotNull String[] cmdArg) {
if (!(sender instanceof ConsoleCommandSender)) {
return;
}
File file = new File(plugin.getDataFolder(), "recovery.txt");
if (!file.exists()) {
MsgUtil.sendMessage(sender, "recovery.txt not exist, do not execute this command unless you know what are you doing.");
return;
}
new BukkitRunnable() {
@Override
public void run() {
try {
Util.backupDatabase();
plugin.getShopLoader().recoverFromFile(Util.readToString(file));
} catch (Throwable e) {
e.printStackTrace();
}
}
}.runTaskAsynchronously(plugin);
}
public boolean canSee(CommandSender sender) {
if (!command.isRegistered()) {
// Unregistered commands should not show up in the help
return false;
}
if (sender instanceof ConsoleCommandSender) {
return true;
}
if (amendedPermission != null) {
return sender.hasPermission(amendedPermission);
} else {
return command.testPermissionSilent(sender);
}
}
public boolean canSee(CommandSender sender) {
if (amendedPermission == null) {
if (sender instanceof ConsoleCommandSender) {
return true;
}
for (Command command : alias.getCommands()) {
if (!command.testPermissionSilent(sender)) {
return false;
}
}
return true;
} else {
return sender.hasPermission(amendedPermission);
}
}
private int executeResultingExecutor(CommandSender sender, Object[] args) throws WrapperCommandSyntaxException {
if(sender instanceof Player && rEx.stream().anyMatch(o -> o.getType() == ExecutorType.PLAYER)) {
return rEx.stream().filter(o -> o.getType() == ExecutorType.PLAYER).findFirst().get().executeWith(sender, args);
} else if(sender instanceof Entity && rEx.stream().anyMatch(o -> o.getType() == ExecutorType.ENTITY)) {
return rEx.stream().filter(o -> o.getType() == ExecutorType.ENTITY).findFirst().get().executeWith(sender, args);
} else if(sender instanceof ConsoleCommandSender && rEx.stream().anyMatch(o -> o.getType() == ExecutorType.CONSOLE)) {
return rEx.stream().filter(o -> o.getType() == ExecutorType.CONSOLE).findFirst().get().executeWith(sender, args);
} else if(sender instanceof BlockCommandSender && rEx.stream().anyMatch(o -> o.getType() == ExecutorType.BLOCK)) {
return rEx.stream().filter(o -> o.getType() == ExecutorType.BLOCK).findFirst().get().executeWith(sender, args);
} else if(sender instanceof ProxiedCommandSender && ex.stream().anyMatch(o -> o.getType() == ExecutorType.PROXY)) {
return ex.stream().filter(o -> o.getType() == ExecutorType.PROXY).findFirst().get().executeWith(sender, args);
} else if(rEx.stream().anyMatch(o -> o.getType() == ExecutorType.ALL)) {
return rEx.stream().filter(o -> o.getType() == ExecutorType.ALL).findFirst().get().executeWith(sender, args);
} else {
throw new WrapperCommandSyntaxException(
new SimpleCommandExceptionType(
new LiteralMessage("This command has no implementations for " + sender.getClass().getSimpleName().toLowerCase())
).create()
);
}
}
private void initializeGameComponents() {
try {
Class<? extends IEntityRegistry> entityRegistry = Class.forName(EntityAPI.INTERNAL_NMS_PATH + ".game.EntityRegistry").asSubclass(IEntityRegistry.class);
GameRegistry.registerPermanently(IEntityRegistry.class, new Reflection().reflect(entityRegistry).getSafeConstructor().getAccessor().invoke());
Class<? extends IEntitySpawnHandler> spawnHandler = Class.forName(EntityAPI.INTERNAL_NMS_PATH + ".game.EntitySpawnHandler").asSubclass(IEntitySpawnHandler.class);
GameRegistry.register(IEntitySpawnHandler.class, new Reflection().reflect(spawnHandler).getSafeConstructor().getAccessor().invoke());
} catch (Exception e) {
ConsoleCommandSender console = this.getServer().getConsoleSender();
console.sendMessage(ChatColor.RED + "-------------------------------");
console.sendMessage(ChatColor.RED + "Failed to initialize the game components!");
console.sendMessage(ChatColor.RED + "-------------------------------");
}
}
@Inject BroadcastScheduler(Loggers loggers,
@Named("configuration") Path configPath,
Scheduler scheduler,
ConsoleCommandSender console,
OnlinePlayers onlinePlayers,
LocalizedMessageMap.Factory messageMapFactory,
DocumentWatcher.Factory<List<BroadcastSchedule>> documentWatcherFactory,
Server localServer,
BroadcastFormatter formatter,
ComponentRenderContext renderer,
BroadcastSettings settings) {
this.logger = loggers.get(getClass());
this.configPath = configPath;
this.configFile = configPath.resolve(CONFIG_FILE);
this.scheduler = scheduler;
this.console = console;
this.onlinePlayers = onlinePlayers;
this.messageMapFactory = messageMapFactory;
this.documentWatcherFactory = documentWatcherFactory;
this.localServer = localServer;
this.formatter = formatter;
this.renderer = renderer;
this.settings = settings;
}
@Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (!(sender instanceof ConsoleCommandSender)) {
sender.sendMessage(ChatColor.RED + "Sorry, this command can only be ran from the console.");
return true;
}
if (args.length == 0 || !args[0].equalsIgnoreCase("reload")) {
sender.sendMessage(ChatColor.RED + "Running BungeeGuard v" + getDescription().getVersion());
sender.sendMessage(ChatColor.GRAY + "Use '/bungeeguard reload' to reload the configuration.");
return true;
}
this.tokenStore.reload();
sender.sendMessage(ChatColor.RED + "BungeeGuard configuration reloaded.");
return true;
}
/**
* Send a message from a channel as console.
*
* @param sender {@code ConsoleCommandSender} - Console sender.
* @param message {@code FancyMessage} - Message to send.
* @param direct {@code boolean} - Send message direct to players on channel.
*/
public void sendMessage(ConsoleCommandSender sender, UltimateFancy message, boolean direct) {
if (direct) {
for (Player p : Bukkit.getOnlinePlayers()) {
UCChannel chp = UChat.get().getPlayerChannel(p);
if (UCPerms.channelReadPerm(p, this) && !this.isIgnoring(p.getName()) && (!this.neeFocus() || chp.equals(this))) {
UChat.get().getUCLogger().timings(timingType.START, "UCChannel#sendMessage()|Direct Message");
message.send(p);
}
}
message.send(sender);
} else {
UChat.get().getUCLogger().timings(timingType.START, "UCChannel#sendMessage()|Fire MessageChannelEvent");
Bukkit.getScheduler().runTask(UChat.get(), () -> UCMessages.sendFancyMessage(new String[0], message.toOldFormat(), this, sender, null));
}
}
@Override
public boolean execute(@NotNull CommandSender sender, @NotNull String name, @NotNull String[] args) {
if (this.permissions.size() > 0) {
for (String perm : this.permissions) {
if (!sender.hasPermission(perm)) {
HubBasics.getMessenger().send(sender, Messages.get(sender, "NO_PERMISSION"));
return true;
}
}
}
try {
if (sender instanceof Player) {
this.execute((Player) sender, args);
} else if (sender instanceof ConsoleCommandSender) { // Is commandblock a Console?
this.execute((ConsoleCommandSender) sender, args);
}
this.execute(sender, args); // Always execute the "universal" one
} catch (Exception ex) {
logger.error("Error while executing command (" + getName() + ")", ex);
}
return true;
}
private void injectConsole() throws Exception {
ConsoleCommandSender consoleSender = this.plugin.getBootstrap().getServer().getConsoleSender();
// get the ServerCommandSender class
Class<?> serverCommandSenderClass = CraftBukkitImplementation.obcClass("command.ServerCommandSender");
// get the perm field
Field permField = serverCommandSenderClass.getDeclaredField("perm");
permField.setAccessible(true);
// get the PermissibleBase instance
PermissibleBase permBase = (PermissibleBase) permField.get(consoleSender);
// create a new instance which delegates to the previous PermissibleBase
PermissibleBase newPermBase = transform(permBase, "internal/console");
if (newPermBase == null) {
return;
}
// inject the new instance
permField.set(consoleSender, newPermBase);
}
@Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof ConsoleCommandSender || !RedProtect.get().ph.hasCommandPerm(sender, "select-we")) {
HandleHelpPage(sender, 1);
return true;
}
Player player = (Player) sender;
if (args.length == 0) {
if (RedProtect.get().hooks.worldEdit) {
Region r = RedProtect.get().rm.getTopRegion(player.getLocation());
if (r == null) {
RedProtect.get().lang.sendMessage(player, "cmdmanager.region.doesexists");
return true;
}
WEHook.setSelectionFromRP(player, r.getMinLocation(), r.getMaxLocation());
}
return true;
}
RedProtect.get().lang.sendCommandHelp(sender, "select-we", true);
return true;
}
public boolean canSee(CommandSender sender) {
if (amendedPermission == null) {
if (sender instanceof ConsoleCommandSender) {
return true;
}
for (Command command : alias.getCommands()) {
if (!command.testPermissionSilent(sender)) {
return false;
}
}
return true;
} else {
return sender.hasPermission(amendedPermission);
}
}
private static Field getPermField(CommandSender sender)
{
Field perm = null;
try
{
if (sender instanceof Player)
{
perm = Class.forName(getVersionedClassName("entity.CraftHumanEntity")).getDeclaredField("perm");
}
else if (sender instanceof ConsoleCommandSender)
{
perm = Class.forName(getVersionedClassName("command.ServerCommandSender")).getDeclaredField("perm");
}
}
catch (Exception e)
{
BungeePerms.getInstance().getDebug().log(e);
}
return perm;
}
@Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof ConsoleCommandSender) {
HandleHelpPage(sender, 1);
return true;
}
Player player = (Player) sender;
if (args.length >= 1) {
StringBuilder wMessage = new StringBuilder();
if (args[0].equals("off")) {
handleWelcome(player, wMessage.toString());
return true;
} else {
for (String arg : args) {
wMessage.append(arg).append(" ");
}
handleWelcome(player, wMessage.toString());
return true;
}
}
RedProtect.get().lang.sendCommandHelp(sender, "welcome", true);
return true;
}
private void checkConfigVersions(Configuration config, Path dataFolder) {
if (config.getInt("config-version") < DefaultConfig.CURRENT_CONFIG_VERSION) {
Path configSource = dataFolder.resolve(ConfigType.DEFAULT_CONFIG.getDestinationFileName());
Path configTarget = dataFolder.resolve("config_old.yml");
try {
Files.move(configSource, configTarget, StandardCopyOption.REPLACE_EXISTING);
URL configResource = getClass().getResource(ConfigType.DEFAULT_CONFIG.getClasspathResourceName());
copyResource(configResource, configSource.toFile());
ConsoleCommandSender sender = Bukkit.getConsoleSender();
sender.sendMessage(ChatColor.RED + "Due to a HeavySpleef update your old configuration has been renamed");
sender.sendMessage(ChatColor.RED + "to config_old.yml and a new one has been generated. Make sure to");
sender.sendMessage(ChatColor.RED + "apply your old changes to the new config");
} catch (IOException e) {
getLogger().log(Level.SEVERE, "Could not create updated configuration due to an IOException", e);
}
}
}
@Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof ConsoleCommandSender) {
HandleHelpPage(sender, 1);
return true;
}
if (args.length == 0) {
HandleHelpPage(sender, 1);
return true;
}
if (args.length == 1) {
try {
int page = Integer.parseInt(args[0]);
HandleHelpPage(sender, page);
return true;
} catch (NumberFormatException ignored) {
}
}
RedProtect.get().lang.sendCommandHelp(sender, "help", true);
return true;
}
public void logToFile(String message) {
ConsoleCommandSender console = SkyWarsReloaded.get().getServer().getConsoleSender();
console.sendMessage(message);
try {
File dataFolder = SkyWarsReloaded.get().getDataFolder();
if (dataFolder.exists() || dataFolder.mkdir()) {
File saveTo = new File(dataFolder, "DebugLog.txt");
if (saveTo.exists() || saveTo.createNewFile()) {
FileWriter fw = new FileWriter(saveTo, true);
PrintWriter pw = new PrintWriter(fw);
pw.println(ChatColor.stripColor(message));
pw.flush();
pw.close();
}
}
} catch(IOException e){
e.printStackTrace();
}
}
@Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof ConsoleCommandSender) {
HandleHelpPage(sender, 1);
return true;
}
Player player = (Player) sender;
if (args.length == 0) {
handleDelete(player);
return true;
}
if (args.length == 1) {
handleDeleteName(player, args[0], "");
return true;
}
if (args.length == 2) {
handleDeleteName(player, args[0], args[1]);
return true;
}
RedProtect.get().lang.sendCommandHelp(sender, "delete", true);
return true;
}
@Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof ConsoleCommandSender) {
HandleHelpPage(sender, 1);
return true;
}
Player player = (Player) sender;
if (args.length == 0) {
Region r = RedProtect.get().rm.getTopRegion(player.getLocation());
if (r != null) {
RedProtect.get().getUtil().addBorder(player, r);
} else {
RedProtect.get().lang.sendMessage(player, "cmdmanager.region.todo.that");
}
return true;
}
RedProtect.get().lang.sendCommandHelp(sender, "border", true);
return true;
}
@Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof ConsoleCommandSender || !RedProtect.get().config.configRoot().purge.enabled) {
HandleHelpPage(sender, 1);
return true;
}
Player player = (Player) sender;
int limit = RedProtect.get().ph.getPurgeLimit(player);
long amount = RedProtect.get().rm.getCanPurgePlayer(player.getUniqueId().toString(), player.getWorld().getName());
RedProtect.get().lang.sendMessage(player, "playerlistener.region.purge-limit", new Replacer[]{
new Replacer("{limit}", String.valueOf(limit)),
new Replacer("{total}", String.valueOf(amount))
});
return true;
}
public void sendCommandHelp(CommandSender sender, String cmd, boolean usage) {
if (sender instanceof ConsoleCommandSender) {
CommandHandlers.HandleHelpPage(sender, 1);
return;
}
if (usage) sendMessage(sender, "correct.usage");
sender.sendMessage(get("cmdmanager.help." + cmd).replace("{cmd}", getCmd(cmd)).replace("{alias}", getCmdAlias(cmd)));
}
public void sendConsoleHelp(ConsoleCommandSender console) {
console.sendMessage(i18nonly("help_title_console").replace("%version%", "Zero " + Main.getVersion()));
console.sendMessage(i18nonly("help_bw_list"));
console.sendMessage(i18nonly("help_bw_stats_other"));
console.sendMessage(i18nonly("help_bw_alljoin"));
console.sendMessage(i18nonly("help_bw_reload"));
}
/**
* Get the most unique id available for the {@param sender}.
* If the server is in online mode, it will return the {@param sender} UUID, otherwise will return the player username in lower case.
*
* @param sender the sender to get the id from
* @return the sender id, null if null sender input
*/
public String getSenderId(CommandSender sender) {
if (sender == null) {
return null;
}
if (sender instanceof ConsoleCommandSender) {
return CONSOLE_SENDER_ID;
}
if (!(sender instanceof OfflinePlayer)) {
return null;
}
val player = (OfflinePlayer) sender;
return server.getOnlineMode() ? player.getUniqueId().toString() : StringUtils.lowerCase(player.getName());
}
@Test(expected = PermissionDeniedException.class)
public void shouldThrowExceptionWithCustomMessageIfSenderIsNotPlayer() {
ConsoleCommandSender sender = mock(ConsoleCommandSender.class);
when(server.getConsoleSender()).thenReturn(sender);
try {
context.runWithSender(sender, testService::testPlayer);
} catch (PermissionDeniedException exception) {
assertEquals("Only players can run this method!", exception.getMessage());
throw exception;
}
}
@Override
@SneakyThrows
public synchronized void onCommand(
@NotNull CommandSender sender, @NotNull String commandLabel, @NotNull String[] cmdArg) {
if (!(sender instanceof ConsoleCommandSender)) {
return;
}
File file = new File(plugin.getDataFolder(), "export.txt");
if (file.exists()) {
file.delete();
file.createNewFile();
} else {
file.createNewFile();
}
new BukkitRunnable() {
@SneakyThrows
@Override
public void run() {
StringBuilder finalReport = new StringBuilder();
plugin
.getShopLoader()
.getOriginShopsInDatabase()
.forEach((shop -> finalReport.append(shop).append("\n")));
BufferedWriter outputStream = new BufferedWriter(new FileWriter(file, false));
outputStream.write(finalReport.toString());
outputStream.close();
MsgUtil.sendMessage(sender, "Done.");
}
}.runTaskAsynchronously(plugin);
}
@Test
public void shouldDispatchConsoleCommand() {
// given
ConsoleCommandSender consoleSender = mock(ConsoleCommandSender.class);
given(server.getConsoleSender()).willReturn(consoleSender);
String command = "my command";
// when
bukkitService.dispatchConsoleCommand(command);
// then
verify(server).dispatchCommand(consoleSender, command);
}
public void sendConsoleHelp(ConsoleCommandSender console) {
console.sendMessage(i18nonly("help_title_console").replace("%version%", "Zero " + Main.getVersion()));
console.sendMessage(i18nonly("help_bw_list"));
console.sendMessage(i18nonly("help_bw_stats_other"));
console.sendMessage(i18nonly("help_bw_alljoin"));
console.sendMessage(i18nonly("help_bw_reload"));
}
public boolean canSee(CommandSender sender) {
if (sender instanceof ConsoleCommandSender) {
return true;
}
if (permission == null) {
return true;
}
return sender.hasPermission(permission);
}
public boolean canSee(CommandSender sender) {
if (sender instanceof ConsoleCommandSender) {
return true;
}
if (!permissionNode.equals("")) {
return sender.hasPermission(permissionNode);
} else {
return true;
}
}