/**
   * Creates a {@link hudson.model.StringParameterValue} and adds it to the provided list. If the
   * parameter with the same name already exists in the list it will be replaced by the new
   * parameter, but its description will be used, unless the parameter type is something else than a
   * StringParameterValue.
   *
   * @param parameters the list of existing parameters.
   * @param value the value.
   * @param escapeQuotes if quote characters should be escaped.
   */
  public void setOrCreateStringParameterValue(
      List<ParameterValue> parameters, String value, boolean escapeQuotes) {
    ParameterValue parameter = null;
    for (ParameterValue p : parameters) {
      if (p.getName().toUpperCase().equals(this.name())) {
        parameter = p;
        break;
      }
    }
    String description = null;
    if (parameter != null) {
      if (parameter instanceof StringParameterValue) {
        // Perhaps it is manually added to remind the user of what it is for.
        description = parameter.getDescription();
      }
      parameters.remove(parameter);
    }
    String stringValue;
    if (escapeQuotes) {
      stringValue = StringUtil.escapeQuotes(value);
    } else {
      stringValue = value;
    }
    if (stringValue == null) {
      stringValue = "";
    }

    parameter = new StringParameterValue(this.name(), stringValue, description);
    parameters.add(parameter);
  }
 /** {@inheritDoc} */
 @Override
 public boolean isSelectable(Run<?, ?> run, EnvVars env) {
   EnvVars otherEnv;
   try {
     otherEnv = run.getEnvironment(TaskListener.NULL);
   } catch (Exception ex) {
     return false;
   }
   if (!(run instanceof AbstractBuild)) {
     // Abstract#getEnvironment(TaskListener) put build parameters to
     // environments, but Run#getEnvironment(TaskListener) doesn't.
     // That means we can't retrieve build parameters from WorkflowRun
     // as it is a subclass of Run, not of AbstractBuild.
     // We need expand build parameters manually.
     // See JENKINS-26694 for details.
     for (ParametersAction pa : run.getActions(ParametersAction.class)) {
       // We have to extract parameters manually as ParametersAction#buildEnvVars
       // (overrides EnvironmentContributingAction#buildEnvVars)
       // is applicable only for AbstractBuild.
       for (ParameterValue pv : pa.getParameters()) {
         pv.buildEnvironment(run, otherEnv);
       }
     }
   }
   for (StringParameterValue spv : filters) {
     if (!spv.value.equals(otherEnv.get(spv.getName()))) {
       return false;
     }
   }
   return true;
 }
 @Override
 public void buildEnvVars(AbstractBuild<?, ?> build, EnvVars env) {
   List<ParameterValue> params = ((Promotion) build).getParameterValues();
   if (params != null) {
     for (ParameterValue value : params) {
       value.buildEnvVars(build, env);
     }
   }
 }
  /** Test for {@link ChoiceParameterDefinition#createValue(StaplerRequest, JSONObject)}. */
  @Test
  public void testCreateValueJSON() {
    final StaplerRequest req = mock(StaplerRequest.class);
    // final JSONObject jo = mock(JSONObject.class); // mockito cannot mock final classes
    final JSONObject jo = null;

    final StringParameterValue value =
        new StringParameterValue("value", (String) SCRIPT_STRINGS_RESULT[1]);

    when(req.bindJSON(StringParameterValue.class, jo)).thenReturn(value);
    final ParameterValue result = choiceParameterDefinition.createValue(req, jo);

    assertEquals(value, result);
    assertEquals(choiceParameterDefinition.getDescription(), result.getDescription());
  }
 private BuildData getBuildData(StringParameterValue pullRequestUrlParam) {
   for (Run<?, ?> build : project.getBuilds()) {
     ParametersAction paramsAction = build.getAction(ParametersAction.class);
     if (paramsAction != null) {
       for (ParameterValue param : paramsAction.getParameters()) {
         if (param.equals(pullRequestUrlParam)) {
           List<BuildData> buildDataList = build.getActions(BuildData.class);
           if (!buildDataList.isEmpty()) {
             return buildDataList.get(0);
           }
         }
       }
     }
   }
   return null;
 }
 private void populateWithParameters(Run build, String externalizableId) {
   ParametersAction action = build.getAction(ParametersAction.class);
   if (action != null) {
     List<ParameterValue> parameters = action.getParameters();
     if (parameters != null) {
       for (ParameterValue parameter : parameters) {
         if (parameter instanceof StringParameterValue) {
           put(
               "parameter-" + parameter.getName(),
               ((StringParameterValue) parameter).value,
               externalizableId);
         }
       }
     }
   }
 }
 @SuppressWarnings("unchecked")
 public boolean matchesRun(Run run) {
   ParametersAction action = run.getAction(ParametersAction.class);
   if (action == null) {
     return false;
   }
   // look for one parameter value that matches our criteria
   for (ParameterValue value : action.getParameters()) {
     String sval = getStringValue(value);
     if (matchesParameter(value.getName(), sval, false, null)) {
       return true;
     }
   }
   // no parameters matched the criteria
   return false;
 }
  public void test() {
    // Test default value
    ArbitraryParameterDefinition testDefinition =
        new ArbitraryParameterDefinition(
            "param_name", "FOo1=BARVALUE1\nfoo2=BAR2", "This is the description.");
    ArbitraryParameterValue testDefaultValue = testDefinition.getDefaultParameterValue();
    EnvVars testVars = new EnvVars(new HashMap<String, String>());
    testDefaultValue.buildEnvVars(null, testVars);
    assertEquals("BARVALUE1", testVars.get("FOo1"));
    assertEquals("BAR2", testVars.get("foo2"));

    // Test custom value
    ParameterValue testCustomValue =
        testDefinition.createValue("param=val val val\nA_Param='vel vel vel'\n");
    testCustomValue.buildEnvVars(null, testVars);
    assertEquals("val val val", testVars.get("param"));
    assertEquals("\'vel vel vel\'", testVars.get("A_Param"));
  }
  /**
   * Creates a {@link hudson.model.ParameterValue} and adds it to the provided list. If the
   * parameter with the same name already exists in the list it will be replaced by the new
   * parameter, but its description will be used, unless the parameter type is something else than a
   * StringParameterValue.
   *
   * @param parameters the list of existing parameters.
   * @param value the value.
   * @param escapeQuotes if quote characters should be escaped.
   * @param clazz the class which extends {@link hudson.model.ParameterValue}.
   */
  private void setOrCreateParameterValue(
      List<ParameterValue> parameters,
      String value,
      boolean escapeQuotes,
      Class<? extends StringParameterValue> clazz) {
    ParameterValue parameter = null;
    for (ParameterValue p : parameters) {
      if (p.getName().toUpperCase().equals(this.name())) {
        parameter = p;
        break;
      }
    }
    String description = null;
    if (parameter != null) {
      if (parameter instanceof StringParameterValue) {
        // Perhaps it is manually added to remind the user of what it is for.
        description = parameter.getDescription();
      }
      parameters.remove(parameter);
    }
    String stringValue;
    if (escapeQuotes) {
      stringValue = StringUtil.escapeQuotes(value);
    } else {
      stringValue = value;
    }
    if (stringValue == null) {
      stringValue = "";
    }

    Class<?>[] types = {String.class, String.class, String.class};
    Object[] args = {this.name(), stringValue, description};
    Constructor<? extends StringParameterValue> constructor;
    try {
      constructor = clazz.getConstructor(types);
      parameter = constructor.newInstance(args);
      parameters.add(parameter);
    } catch (Exception ex) {
      parameter = null;
    }
  }
  /*
   * Convert an individual Hudson parameter definition to an OSLC Property.
   */
  private Property toProperty(StaplerRequest request, ParameterDefinition def)
      throws URISyntaxException {
    Property prop = new Property();
    prop.setName(def.getName());
    prop.setDescription(def.getDescription());

    if (def instanceof BooleanParameterDefinition) {
      prop.setValueType(new URI(XSDDatatype.XSDboolean.getURI()));
    } else if (def instanceof StringParameterDefinition
        || def instanceof PasswordParameterDefinition) {
      prop.setValueType(new URI(XSDDatatype.XSDstring.getURI()));
    } else if (def instanceof ChoiceParameterDefinition) {
      prop.setValueType(new URI(XSDDatatype.XSDstring.getURI()));
      ChoiceParameterDefinition choices = (ChoiceParameterDefinition) def;
      prop.setAllowedValuesCollection(choices.getChoices());
    }
    // TODO: Other types?

    ParameterValue defaultValue = def.getDefaultParameterValue();
    if (defaultValue == null) {
      prop.setOccurs(Occurs.ExactlyOne);
    } else {
      prop.setOccurs(Occurs.ZeroOrOne);
      if (!defaultValue.isSensitive()) {
        if (defaultValue instanceof BooleanParameterValue) {
          BooleanParameterValue bool = (BooleanParameterValue) defaultValue;
          prop.setDefaultValue(bool.value);
        } else if (defaultValue instanceof StringParameterValue) {
          StringParameterValue str = (StringParameterValue) defaultValue;
          prop.setDefaultValue(str.value);
        }
        // TODO: Other types?
      }
    }

    return prop;
  }
 private static ParametersAction mergeParameters(ParametersAction base, ParametersAction overlay) {
   LinkedHashMap<String, ParameterValue> params = new LinkedHashMap<String, ParameterValue>();
   for (ParameterValue param : base.getParameters()) params.put(param.getName(), param);
   for (ParameterValue param : overlay.getParameters()) params.put(param.getName(), param);
   return new ParametersAction(params.values().toArray(new ParameterValue[params.size()]));
 }
 /**
  * Method for replacing the old parametervalue with new parameter value
  *
  * @param oldValue ParameterValue
  * @param newValue The value that is submitted by user using form.
  * @return ParameterValue
  */
 private ParameterValue cloneParameter(ParameterValue oldValue, String newValue) {
   if (oldValue instanceof StringParameterValue) {
     return new StringParameterValue(oldValue.getName(), newValue, oldValue.getDescription());
   } else if (oldValue instanceof BooleanParameterValue) {
     return new BooleanParameterValue(
         oldValue.getName(), Boolean.valueOf(newValue), oldValue.getDescription());
   } else if (oldValue instanceof RunParameterValue) {
     return new RunParameterValue(oldValue.getName(), newValue, oldValue.getDescription());
   } else if (oldValue instanceof PasswordParameterValue) {
     return new PasswordParameterValue(oldValue.getName(), newValue, oldValue.getDescription());
   } else if (oldValue.getClass().getName().equals(SVN_TAG_PARAM_CLASS)) {
     /** getClass().getName() to avoid dependency on svn plugin. */
     return new StringParameterValue(oldValue.getName(), newValue, oldValue.getDescription());
   }
   throw new IllegalArgumentException("Unrecognized parameter type: " + oldValue.getClass());
 }