From d2754b99c98e7d4640efe19437567f868b6ad994 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?K=C3=A9vin=20Jimenez?= <jdkeke142@protonmail.com>
Date: Sat, 9 Mar 2019 17:03:04 +0100
Subject: [PATCH] =?UTF-8?q?Add=20support=20for=20CommandPermission=20annot?=
 =?UTF-8?q?ation=20as=20parameter=20for=20permiss=E2=80=A6=20(#197)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

…ions by Optional annotation

In the past we could not handle a permission in relation to the presence of an optional argument, it forced us to manage it in the body of the command, and could be repetitive and boring, note that it also works with the annotation Default
---
 .idea/compiler.xml                            | 15 ++++++-----
 .../commands/CommandExecutionContext.java     | 11 ++++++--
 .../co/aikar/commands/CommandParameter.java   | 25 ++++++++++++++++---
 .../co/aikar/commands/RegisteredCommand.java  | 19 +++++++++++++-
 .../annotation/CommandPermission.java         |  4 +--
 5 files changed, 58 insertions(+), 16 deletions(-)

diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index 6b817330..c61c5f2b 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -7,17 +7,16 @@
         <sourceOutputDir name="target/generated-sources/annotations" />
         <sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
         <outputRelativeToContentRoot value="true" />
-        <module name="acf-sponge" />
         <module name="acf" />
-        <module name="acf-example" />
-        <module name="example-plugin" />
-        <module name="acf-paper" />
-        <module name="acf-jda" />
-        <module name="commands" />
-        <module name="acf-core" />
-        <module name="acf-velocity" />
         <module name="acf-bukkit" />
         <module name="acf-bungee" />
+        <module name="acf-core" />
+        <module name="acf-example" />
+        <module name="acf-jda" />
+        <module name="acf-paper" />
+        <module name="acf-sponge" />
+        <module name="acf-velocity" />
+        <module name="example-plugin" />
       </profile>
     </annotationProcessing>
     <bytecodeTargetLevel>
diff --git a/core/src/main/java/co/aikar/commands/CommandExecutionContext.java b/core/src/main/java/co/aikar/commands/CommandExecutionContext.java
index f23a553e..620a20b2 100644
--- a/core/src/main/java/co/aikar/commands/CommandExecutionContext.java
+++ b/core/src/main/java/co/aikar/commands/CommandExecutionContext.java
@@ -27,9 +27,10 @@ import java.lang.annotation.Annotation;
 import java.lang.reflect.Parameter;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 @SuppressWarnings({"WeakerAccess"})
-public class CommandExecutionContext <CEC extends CommandExecutionContext, I extends CommandIssuer> {
+public class CommandExecutionContext<CEC extends CommandExecutionContext, I extends CommandIssuer> {
     private final RegisteredCommand cmd;
     private final CommandParameter param;
     protected final I issuer;
@@ -69,7 +70,7 @@ public class CommandExecutionContext <CEC extends CommandExecutionContext, I ext
     }
 
     public boolean isLastArg() {
-        return cmd.parameters.length -1 == index;
+        return cmd.parameters.length - 1 == index;
     }
 
     public int getNumParams() {
@@ -108,6 +109,10 @@ public class CommandExecutionContext <CEC extends CommandExecutionContext, I ext
         return null;
     }
 
+    public Set<String> getPermissions() {
+        return param.getPermissions();
+    }
+
     public boolean isOptional() {
         return param.isOptional();
     }
@@ -170,6 +175,7 @@ public class CommandExecutionContext <CEC extends CommandExecutionContext, I ext
 
     /**
      * This method will not support annotation processors!! use getAnnotationValue or hasAnnotation
+     *
      * @deprecated Use {@link #getAnnotationValue(Class)}
      */
     @Deprecated
@@ -226,6 +232,7 @@ public class CommandExecutionContext <CEC extends CommandExecutionContext, I ext
     public String joinArgs() {
         return ACFUtil.join(args, " ");
     }
+
     public String joinArgs(String sep) {
         return ACFUtil.join(args, sep);
     }
diff --git a/core/src/main/java/co/aikar/commands/CommandParameter.java b/core/src/main/java/co/aikar/commands/CommandParameter.java
index f13bcb51..60e61e91 100644
--- a/core/src/main/java/co/aikar/commands/CommandParameter.java
+++ b/core/src/main/java/co/aikar/commands/CommandParameter.java
@@ -23,6 +23,7 @@
 
 package co.aikar.commands;
 
+import co.aikar.commands.annotation.CommandPermission;
 import co.aikar.commands.annotation.Conditions;
 import co.aikar.commands.annotation.Default;
 import co.aikar.commands.annotation.Description;
@@ -37,10 +38,13 @@ import co.aikar.commands.contexts.IssuerOnlyContextResolver;
 import co.aikar.commands.contexts.OptionalContextResolver;
 
 import java.lang.reflect.Parameter;
+import java.util.Arrays;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 
-public class CommandParameter <CEC extends CommandExecutionContext<CEC, ? extends CommandIssuer>> {
+public class CommandParameter<CEC extends CommandExecutionContext<CEC, ? extends CommandIssuer>> {
     private final Parameter parameter;
     private final Class<?> type;
     private final String name;
@@ -49,6 +53,8 @@ public class CommandParameter <CEC extends CommandExecutionContext<CEC, ? extend
 
     private ContextResolver<?, CEC> resolver;
     private boolean optional;
+    private Set<String> permissions = new HashSet<>();
+    private String permission;
     private String description;
     private String defaultValue;
     private String syntax;
@@ -82,6 +88,7 @@ public class CommandParameter <CEC extends CommandExecutionContext<CEC, ? extend
         }
 
         this.optional = annotations.hasAnnotation(param, Optional.class) || this.defaultValue != null || (isLast && type == String[].class);
+        this.permission = annotations.getAnnotationValue(param, CommandPermission.class, Annotations.REPLACEMENTS | Annotations.NO_EMPTY);
         this.optionalResolver = isOptionalResolver(resolver);
         this.requiresInput = !this.optional && !this.optionalResolver;
         //noinspection unchecked
@@ -109,6 +116,7 @@ public class CommandParameter <CEC extends CommandExecutionContext<CEC, ? extend
             parseFlags(flags);
         }
         inheritContextFlags(command.scope);
+        this.computePermissions();
     }
 
     private void inheritContextFlags(BaseCommand scope) {
@@ -134,10 +142,17 @@ public class CommandParameter <CEC extends CommandExecutionContext<CEC, ? extend
         }
     }
 
+    private void computePermissions() {
+        this.permissions.clear();
+        if (this.permission != null && !this.permission.isEmpty()) {
+            this.permissions.addAll(Arrays.asList(ACFPatterns.COMMA.split(this.permission)));
+        }
+    }
+
     private boolean isOptionalResolver(ContextResolver<?, CEC> resolver) {
         return resolver instanceof IssuerAwareContextResolver
-            || resolver instanceof IssuerOnlyContextResolver
-            || resolver instanceof OptionalContextResolver;
+                || resolver instanceof IssuerOnlyContextResolver
+                || resolver instanceof OptionalContextResolver;
     }
 
 
@@ -256,4 +271,8 @@ public class CommandParameter <CEC extends CommandExecutionContext<CEC, ? extend
     public void setConditions(String conditions) {
         this.conditions = conditions;
     }
+
+    public Set<String> getPermissions() {
+        return permissions;
+    }
 }
diff --git a/core/src/main/java/co/aikar/commands/RegisteredCommand.java b/core/src/main/java/co/aikar/commands/RegisteredCommand.java
index 9c519f51..7fc2f56c 100644
--- a/core/src/main/java/co/aikar/commands/RegisteredCommand.java
+++ b/core/src/main/java/co/aikar/commands/RegisteredCommand.java
@@ -226,11 +226,13 @@ public class RegisteredCommand<CEC extends CommandExecutionContext<CEC, ? extend
             if (requiresInput && remainingRequired > 0) {
                 remainingRequired--;
             }
+
             if (args.isEmpty() && !(isLast && type == String[].class)) {
                 if (allowOptional && parameter.getDefaultValue() != null) {
                     args.add(parameter.getDefaultValue());
                 } else if (allowOptional && parameter.isOptional()) {
                     Object value = parameter.isOptionalResolver() ? resolver.getContext(context) : null;
+
                     if (value == null && parameter.getClass().isPrimitive()) {
                         throw new IllegalStateException("Parameter " + parameter.getName() + " is primitive and does not support Optional.");
                     }
@@ -244,6 +246,7 @@ public class RegisteredCommand<CEC extends CommandExecutionContext<CEC, ? extend
                     return null;
                 }
             }
+
             if (parameter.getValues() != null) {
                 String arg = !args.isEmpty() ? args.get(0) : "";
 
@@ -258,13 +261,27 @@ public class RegisteredCommand<CEC extends CommandExecutionContext<CEC, ? extend
                         possible.add(s.toLowerCase());
                     }
                 }
-
                 if (!possible.contains(arg.toLowerCase())) {
                     throw new InvalidCommandArgument(MessageKeys.PLEASE_SPECIFY_ONE_OF,
                             "{valid}", ACFUtil.join(possible, ", "));
                 }
             }
             Object paramValue = resolver.getContext(context);
+
+            Set<String> parameterPermissions = parameter.getPermissions();
+            if (!parameter.isOptionalResolver() && parameterPermissions != null && !parameterPermissions.isEmpty()) {
+                if (allowOptional && parameter.isOptional()) {
+                    for (String perm : parameterPermissions) {
+                        if (!perm.isEmpty() && !sender.hasPermission(perm)) {
+                            sender.sendMessage(MessageType.ERROR, MessageKeys.PERMISSION_DENIED);
+                            return null;
+                        }
+                    }
+                } else {
+                    throw new IllegalStateException("Using CommandPermission annotation on parameter that is not optional is useless and you should not do it.");
+                }
+            }
+
             //noinspection unchecked
             this.manager.conditions.validateConditions(context, paramValue);
             passedArgs.put(parameterName, paramValue);
diff --git a/core/src/main/java/co/aikar/commands/annotation/CommandPermission.java b/core/src/main/java/co/aikar/commands/annotation/CommandPermission.java
index 96c3111a..b41bafb5 100644
--- a/core/src/main/java/co/aikar/commands/annotation/CommandPermission.java
+++ b/core/src/main/java/co/aikar/commands/annotation/CommandPermission.java
@@ -30,11 +30,11 @@ import java.lang.annotation.Target;
 
 /**
  * Sets the permission required to perform this command.
- *
+ * <p>
  * Permission format will vary based on implementation platform
  */
 @Retention(RetentionPolicy.RUNTIME)
-@Target({ElementType.METHOD, ElementType.TYPE})
+@Target({ElementType.METHOD, ElementType.TYPE, ElementType.PARAMETER})
 public @interface CommandPermission {
     String value();
 }