import org.spongepowered.api.command.CommandPermissionException; //导入依赖的package包/类
private void backpackcheck(Player player) throws CommandException {
    Path file = Paths.get(this.vt.getConfigPath() + File.separator + "backpacks" + File.separator + player.getUniqueId().toString() + ".backpack");
    if (!Files.exists(file)) {
        throw new CommandPermissionException(Text.of("Sorry there is no backpack data for " + player.getName()));
    } else {
        String content = null;
        try {
            content = new String(Files.readAllBytes(file), "UTF-8");
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (content == "{}") {
            throw new CommandPermissionException(Text.of("Sorry there is no backpack data for " + player.getName()));
        }
    }
}
 

import org.spongepowered.api.command.CommandPermissionException; //导入依赖的package包/类
@Override public CommandResult process(CommandSource source, String arguments) throws CommandException {
    // Get the first argument, is it a child?
    final CommandArgs args = new CommandArgs(arguments, tokenizer.tokenize(arguments, false));

    Optional<CommandSpec> optionalSpec = getSpec(args);
    if (optionalSpec.isPresent()) {
        CommandSpec spec = optionalSpec.get();
        CommandContext context = new CommandContext();
        spec.checkPermission(source);
        spec.populateContext(source, args, context);
        return spec.getExecutor().execute(source, context);
    }

    if (testPermission(source)) {
        // Else, what do we want to do here?
        source.sendMessage(Text.of("Phonon from Nucleus."));
        return CommandResult.success();
    }

    throw new CommandPermissionException();
}
 

import org.spongepowered.api.command.CommandPermissionException; //导入依赖的package包/类
private void backpackchecklock(Player player) throws CommandException {

        Path file = Paths.get(this.vt.getConfigPath() + File.separator + "backpacks" + File.separator + player.getUniqueId().toString() + ".lock");
        if (Files.exists(file)) {
            throw new CommandPermissionException(Text.of("Sorry currently your backpack is locked."));
        }
    }
 

import org.spongepowered.api.command.CommandPermissionException; //导入依赖的package包/类
@Override
public CommandResult execute(CommandSource src, CommandContext args) throws CommandException {
    final Player player_args = args.<Player>getOne("player").orElse(null);
    if (src.hasPermission(VTPermissions.COMMAND_BACKPACKLOCK)) {
        if (player_args != null) {
            if (args.hasAny("l") || args.hasAny("u")) {
                if (args.hasAny("l")) {
                    if (!Tools.backpackchecklock(player_args, this.vt)) {
                        this.bplock(player_args, src);
                    }
                }
                if (args.hasAny("u")) {
                    if (Tools.backpackchecklock(player_args, this.vt)) {
                        this.bpunlock(player_args, src);
                    }
                }
            } else {
                if (Tools.backpackchecklock(player_args, this.vt)) {
                    this.bpunlock(player_args, src);
                } else {
                    this.bplock(player_args, src);
                }
            }
        }
    } else {
        throw new CommandPermissionException(Text.of("You don't have permission to use this command."));
    }
    return CommandResult.success();
}
 

import org.spongepowered.api.command.CommandPermissionException; //导入依赖的package包/类
@Override
public CommandResult execute(CommandSource src, CommandContext args) throws CommandException {
    if (src.hasPermission(VTPermissions.COMMAND_MAIN)) {
    } else {
        throw new CommandPermissionException(Text.of("You don't have permission to use this command."));
    }

    return CommandResult.success();
}
 

import org.spongepowered.api.command.CommandPermissionException; //导入依赖的package包/类
@Override
public CommandResult execute(CommandSource src, CommandContext args) throws CommandException {
    if (src instanceof Player) {
        if (src.hasPermission(VTPermissions.COMMAND_ANVIL)) {
            final VirtualAnvil VA = new VirtualAnvil(Tools.getPlayerE(src, this.vt));

            return inv.Open(src, VA, "minecraft:anvil", "Virtual Anvil");
        } else {
            throw new CommandPermissionException(Text.of("You don't have permission to use this command."));
        }
    } else {
        throw new CommandException(Text.of("You can't use this command if you are not a player!"));
    }

}
 

import org.spongepowered.api.command.CommandPermissionException; //导入依赖的package包/类
@Override
public CommandResult execute(CommandSource src, CommandContext args) throws CommandException {
    if (src instanceof Player) {
        if (src.hasPermission(VTPermissions.COMMAND_ENDERCHEST)) {
            return inv.Open(src, args, "enderchest");
        } else {
            throw new CommandPermissionException(Text.of("You don't have permission to use this command."));
        }
    } else {
        throw new CommandException(Text.of("You can't use this command if you are not a player!"));
    }
}
 

import org.spongepowered.api.command.CommandPermissionException; //导入依赖的package包/类
@Override
public CommandResult execute(CommandSource src, CommandContext args) throws CommandException {
    if (src instanceof Player) {
        if (src.hasPermission(VTPermissions.COMMAND_WORKBENCH)) {
            return inv.Open(src, new VirtualWorkbench(Tools.getPlayerE(src, this.vt)), "minecraft:crafting_table", "Workbench");
        } else {
            throw new CommandPermissionException(Text.of("You don't have permission to use this command."));
        }
    } else {
        throw new CommandException(Text.of("You can't use this command if you are not a player!"));
    }

}
 

import org.spongepowered.api.command.CommandPermissionException; //导入依赖的package包/类
@Override
public CommandResult execute(CommandSource src, CommandContext args) throws CommandException {
	Collection<WorldProperties> worlds;

	if (args.hasAny(PARAM_WORLD)) {
		worlds = args.<WorldProperties>getAll(PARAM_WORLD);
	} else if (args.hasAny(PARAM_ALL)) {
		worlds = Sponge.getGame().getServer().getAllWorldProperties();
	} else if (src instanceof Locatable) {
		worlds = Collections.singleton(((Player) src).getWorld().getProperties());
	} else
		throw new CommandException(Text.of("You have to enter a world when using this from the console!"), true);

	final boolean mode = args.<Boolean>getOne(PARAM_MODE).get();
	final String permission = BASE_PERMISSION + '.' + (mode ? "enable" : "disable") + '.';
	final List<String> worldNames = worlds.stream().map(WorldProperties::getWorldName)
			.filter(world -> src.hasPermission(permission + world)).collect(Collectors.toList());

	worldNames.stream().forEach(world -> AuraSunDial.getConfig().setWorld(world, mode));

	AuraSunDial.getConfig().save();

	if (worldNames.size() > 0) {
		src.sendMessage(Text.of((mode ? "Enabled" : "Disabled") + " realtime on these worlds: "
				+ worldNames.stream().collect(Collectors.joining(", "))));
	} else
		throw new CommandPermissionException();

	return CommandResult.successCount(worldNames.size());
}
 

import org.spongepowered.api.command.CommandPermissionException; //导入依赖的package包/类
@Override
public CommandResult execute(CommandSource src, CommandContext args) throws CommandException {
    List<Text> cmdList = COMMAND_LIST.apply(src);

    if(cmdList.isEmpty())
        throw new CommandPermissionException();

    plugin.getPagination().builder()
            .contents(cmdList)
            .title(Text.of(GRAY, "HelpTickets Commands"))
            .paddingString("=")
            .sendTo(src);
    return CommandResult.success();
}
 

import org.spongepowered.api.command.CommandPermissionException; //导入依赖的package包/类
@Override
public CommandResult execute(CommandSource src, CommandContext ctx) {
    List<User> userValues = new ArrayList<>(ctx.getAll("user"));
    WorldProperties worldProperties = ctx.<WorldProperties>getOne("world").orElse(null);
    User user = null;
    if (userValues.size() > 0) {
        user = userValues.get(0);
    }
    if (src instanceof Player) {
        this.displayOwned = true;
    }

    if (user == null) {
        if (!(src instanceof Player)) {
            GriefPreventionPlugin.sendMessage(src, GriefPreventionPlugin.instance.messageData.commandPlayerInvalid.toText());
            return CommandResult.success();
        }

        user = (User) src;
    }
    if (worldProperties == null) {
        worldProperties = Sponge.getServer().getDefaultWorld().get();
    }

    // otherwise if no permission to delve into another player's claims data or self
    if (!src.hasPermission(GPPermissions.COMMAND_CLAIM_LIST)) {
        try {
            throw new CommandPermissionException();
        } catch (CommandPermissionException e) {
            src.sendMessage(e.getText());
            return CommandResult.success();
        }
    }

    String arguments = "";
    if (user != null) {
        arguments = user.getName();
    }
    if (worldProperties != null) {
        if (arguments.isEmpty()) {
            arguments = worldProperties.getWorldName();
        } else {
            arguments += " " + worldProperties.getWorldName();
        }
    }

    this.canListOthers = src.hasPermission(GPPermissions.LIST_OTHER_CLAIMS);
    this.canListAdmin = src.hasPermission(GPPermissions.LIST_OTHER_CLAIMS);
    showClaimList(src, user, this.forcedType, worldProperties);
    return CommandResult.success();
}
 

import org.spongepowered.api.command.CommandPermissionException; //导入依赖的package包/类
public void checkPlayerPermission(Subject player) throws CommandPermissionException {
    if (settings.getGeneral().isPlayerPermissions() && !player.hasPermission(permission)) {
        throw new CommandPermissionException();
    }
}
 

import org.spongepowered.api.command.CommandPermissionException; //导入依赖的package包/类
default void checkPermSuffix(CommandSource sender, String suffix) throws CommandException {
    String perm = getBasePermission() + "." + suffix;
    if (!sender.hasPermission(perm)) {
        throw new CommandPermissionException();
    }
}
 

import org.spongepowered.api.command.CommandPermissionException; //导入依赖的package包/类
default void checkPermission(CommandSource sender, String permission) throws CommandException {
    if (!sender.hasPermission(permission)) {
        throw new CommandPermissionException();
    }
}