Ref #25533: allow using names for parameter values

Author: LEDfan

src/main/java/eu/openanalytics/containerproxy/model/runtime/AllowedParametersForUser.java

@@ -29,9 +29,7 @@
 public class AllowedParametersForUser {
 
     /**
-     * Mapping of ParameterName to a list of allowed values.
-     * The integer represents the index of the parameter.
-     * The list is sorted by the index.
+     * Mapping of the id of the parameter to the (human friendly) names.
      */
     private final Map<String, List<String>> values;
 

src/main/java/eu/openanalytics/containerproxy/model/spec/ParameterDefinition.java

@@ -20,43 +20,93 @@
  */
 package eu.openanalytics.containerproxy.model.spec;
 
-import org.apache.commons.lang3.StringUtils;
-import org.apache.logging.log4j.util.Strings;
+import org.apache.commons.collections4.BidiMap;
+import org.apache.commons.collections4.bidimap.DualHashBidiMap;
+import org.springframework.boot.context.properties.ConstructorBinding;
 
+import java.util.List;
+
+@ConstructorBinding
 public class ParameterDefinition {
 
-    private String id;
-    private String displayName;
-    private String description;
+    private final String id;
+    private final String displayName;
+    private final String description;
+
+    // a mapping of the raw value (used in the backend) to a human friendly name used in the front-end
+    private final BidiMap<String, String> valueNames;
+
+    public ParameterDefinition(String id, String displayName, String description, List<ValueName> valueNames) {
+        this.id = id;
+        this.displayName = displayName;
+        this.description = description;
+        this.valueNames = new DualHashBidiMap<>();
+        if (valueNames != null) {
+            for (ValueName valueName : valueNames) {
+                if (this.valueNames.containsKey(valueName.value)) {
+                    throw new IllegalStateException(String.format("A ValueName mapping already contains a mapping for value \"%s\"", valueName.value));
+                }
+                if (this.valueNames.containsValue(valueName.name)) {
+                    throw new IllegalStateException(String.format("A ValueName mapping already contains a mapping with the name \"%s\"", valueName.name));
+                }
+                this.valueNames.put(valueName.value, valueName.name);
+            }
+        }
+    }
 
     public String getDisplayName() {
         return displayName;
     }
 
+    // used in Thymeleaf template!
+    @SuppressWarnings("unused")
     public String getDisplayNameOrId() {
         if (displayName != null) {
             return displayName;
         }
         return id;
     }
 
-    public void setDisplayName(String displayName) {
-        this.displayName = displayName;
-    }
-
     public String getDescription() {
         return description;
     }
 
-    public void setDescription(String description) {
-        this.description = description;
-    }
-
     public String getId() {
         return id;
     }
 
-    public void setId(String id) {
-        this.id = id;
+    /**
+     * Given the (backend) value, return the human friendly name for the value.
+     * @param value the backend-value
+     * @return the human friendly name of the value
+     */
+    public String getNameOfValue(String value) {
+        return valueNames.getOrDefault(value, value);
+    }
+
+    public boolean hasNameForValue(String value) {
+        return valueNames.containsKey(value);
+    }
+
+    /**
+     * Given the (human friendly name), return the backend value
+     * @param name the human-friendly name
+     * @return the backend value
+     */
+    public String getValueForName(String name) {
+        return valueNames.getKey(name);
     }
+
+    @ConstructorBinding
+    public static class ValueName {
+
+        private final String name;
+        private final String value;
+
+        public ValueName(String name, String value) {
+            this.name = name;
+            this.value = value;
+        }
+    }
+
 }

src/main/java/eu/openanalytics/containerproxy/service/ParametersService.java

@@ -27,17 +27,16 @@
 import eu.openanalytics.containerproxy.model.spec.ProxySpec;
 import eu.openanalytics.containerproxy.spec.IProxySpecProvider;
 import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.tuple.Pair;
 import org.springframework.security.core.Authentication;
 import org.springframework.stereotype.Service;
 
 import javax.annotation.PostConstruct;
 import java.util.ArrayList;
-import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
@@ -118,10 +117,21 @@ private void validateSpec(ProxySpec spec) {
 
     }
 
-    public boolean validateRequest(Authentication auth, ProxySpec resolvedSpec, ProvidedParameters providedParameters) throws InvalidParametersException {
-        Parameters parameters = resolvedSpec.getParameters();
+    /**
+     * Parses and validates the parameters provided by a user.
+     * - checks that a value is included for every parameter
+     * - checks that the user is allowed to use these values
+     * - converts the (human friendly) name to the backend value
+     * @param auth the user
+     * @param spec the Proxy spec to which this requests belong
+     * @param providedParameters the parameters as provided by the user (using human friendly names)
+     * @return the parsed parameters (using backend values)
+     * @throws InvalidParametersException
+     */
+    public Optional<ProvidedParameters> parseAndValidateRequest(Authentication auth, ProxySpec spec, ProvidedParameters providedParameters) throws InvalidParametersException {
+        Parameters parameters = spec.getParameters();
         if (parameters == null) {
-            return false;
+            return Optional.empty();
         }
 
         if (providedParameters == null) {
@@ -142,29 +152,54 @@ public boolean validateRequest(Authentication auth, ProxySpec resolvedSpec, Prov
 
         // check if the combination of values is allowed
         for (Parameters.ValueSet valueSet : parameters.getValueSets()) {
-            if (!accessControlEvaluationService.checkAccess(auth, resolvedSpec, valueSet.getAccessControl())) {
+            if (!accessControlEvaluationService.checkAccess(auth, spec, valueSet.getAccessControl())) {
                 continue;
             }
-            if (areParametersAllowedByValueSet(parameters.getIds(), valueSet, providedParameters)) {
-                return true; // parameters are allowed
+            Optional<ProvidedParameters> res = convertParametersIfAllowed(parameters.getDefinitions(), valueSet, providedParameters);
+            if (res.isPresent()) {
+                return res; // parameters are allowed, return the converted values
             }
         }
 
         throw new InvalidParametersException("Provided parameter values are not allowed");
     }
 
-    private boolean areParametersAllowedByValueSet(List<String> parameterIds, Parameters.ValueSet valueSet, ProvidedParameters providedParameters) {
-        for (String parameterId : parameterIds) {
-            if (!providedParameters.containsParameter(parameterId)) {
-                throw new IllegalStateException("Could not find value for parameter with id" + parameterId);
+    /**
+     * Checks whether the provided parameters are allowed by the given valueSet.
+     * Returns the converted backend values if (and only if) the provided human-friendly values are allowed by this
+     * valueSet.
+     * @param parameters the parameter defintiions
+     * @param valueSet the valueSet to check
+     * @param providedParameters the parameters as provided by the user (using human friendly names)
+     * @return the converted values (i.e. using backend values) if allowed otherwise nothing
+     */
+    private Optional<ProvidedParameters> convertParametersIfAllowed(List<ParameterDefinition> parameters, Parameters.ValueSet valueSet, ProvidedParameters providedParameters) {
+        Map<String, String> res = new HashMap<>();
+        for (ParameterDefinition parameter: parameters) {
+            if (!providedParameters.containsParameter(parameter.getId())) {
+                throw new IllegalStateException("Could not find value for parameter with id" + parameter.getId());
+            }
+            String providedValue = providedParameters.getValue(parameter.getId());
+            String backendValue = parameter.getValueForName(providedValue);
+            if (backendValue == null) {
+                // if we did not find a backend value for the provided value (i.e. the user already provided a backend value),
+                // check that no mapping exists for this backend value.
+                // The backend value can only be used if a mapping does not exist.
+                if (parameter.hasNameForValue(providedValue)) {
+                    return Optional.empty();
+                } else {
+                    backendValue = providedValue;
+                }
             }
-            String providedValue = providedParameters.getValue(parameterId);
-            if (!valueSet.getParameterValues(parameterId).contains(providedValue)) {
-                return false;
+            // check whether the backendValue is in the list of allowed values of this valueSet
+            if (!valueSet.getParameterValues(parameter.getId()).contains(backendValue)) {
+                return Optional.empty();
             }
+            res.put(parameter.getId(), backendValue);
         }
         // providedParameters contains an allowed value for every parameter
-        return true;
+        // return the backend values (instead of the names provided by the user)
+        return Optional.of(new ProvidedParameters(res));
     }
 
     public AllowedParametersForUser calculateAllowedParametersForUser(Authentication auth, ProxySpec proxySpec) {
@@ -174,7 +209,7 @@ public AllowedParametersForUser calculateAllowedParametersForUser(Authentication
         }
         List<String> parameterIds = parameters.getIds();
 
-        // 1. check which ValueSets are allowed for this
+        // 1. check which ValueSets are allowed for this user
         List<Parameters.ValueSet> allowedValueSets = parameters.getValueSets().stream()
                 .filter(v -> accessControlEvaluationService.checkAccess(auth, proxySpec, v.getAccessControl()))
                 .collect(Collectors.toList());
@@ -186,25 +221,24 @@ public AllowedParametersForUser calculateAllowedParametersForUser(Authentication
         // for every set of allowed values
         for (Parameters.ValueSet valueSet : allowedValueSets) {
             // for every parameter in this set
-            for (String parameterId : parameterIds) {
-                valuesToIndex.computeIfAbsent(parameterId, (k) -> new HashMap<>());
-                values.computeIfAbsent(parameterId, (k) -> new ArrayList<>());
+            for (ParameterDefinition parameter : parameters.getDefinitions()) {
+                valuesToIndex.computeIfAbsent(parameter.getId(), (k) -> new HashMap<>());
+                values.computeIfAbsent(parameter.getId(), (k) -> new ArrayList<>());
                 // for every value of this parameter
-                for (String value : valueSet.getParameterValues(parameterId)) {
-                    if (!valuesToIndex.get(parameterId).containsKey(value)) {
+                for (String value : valueSet.getParameterValues(parameter.getId())) {
+                    if (!valuesToIndex.get(parameter.getId()).containsKey(value)) {
                         // add it to allValues if it does not yet exist
-                        Integer newIndex = values.get(parameterId).size() + 1;
-                        valuesToIndex.get(parameterId).put(value, newIndex);
-                        values.get(parameterId).add(value);
+                        Integer newIndex = values.get(parameter.getId()).size() + 1;
+                        valuesToIndex.get(parameter.getId()).put(value, newIndex);
+                        values.get(parameter.getId()).add(parameter.getNameOfValue(value));
                     }
                 }
             }
         }
 
-        // 3. compute the set of allowed values
+        // 3. compute the set of allowed values for every value-set
         HashSet<List<Integer>> allowedCombinations = new HashSet<>();
 
-        // for every value-set
         for (Parameters.ValueSet valueSet : allowedValueSets) {
             allowedCombinations.addAll(getAllowedCombinationsForSingleValueSet(parameterIds, valueSet, valuesToIndex));
         }

src/main/java/eu/openanalytics/containerproxy/service/RuntimeValueService.java

@@ -33,6 +33,7 @@
 import org.springframework.stereotype.Service;
 
 import javax.inject.Inject;
+import java.util.Optional;
 
 /**
  * Determines the RuntimeValue when a proxy gets started.
@@ -68,8 +69,9 @@ public void init() {
     }
 
     public void createRuntimeValues(ProxySpec spec, ProvidedParameters parameters, Proxy proxy) throws InvalidParametersException {
-        if (parametersService.validateRequest(userService.getCurrentAuth(), spec, parameters)) {
-            proxy.addRuntimeValue(new RuntimeValue(ParametersKey.inst, parameters));
+        Optional<ProvidedParameters> providedParametersOptional = parametersService.parseAndValidateRequest(userService.getCurrentAuth(), spec, parameters);
+        if (providedParametersOptional.isPresent()) {
+            proxy.addRuntimeValue(new RuntimeValue(ParametersKey.inst, providedParametersOptional.get()));
         }
         SpecExpressionContext context = SpecExpressionContext.create(
                 proxy,