import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
private static void initConverters() {
  // inner converters
  for (Class<? extends Property> propertyCls : PROPERTY_MAP.keySet()) {
    addInnerConverter(propertyCls);
  }

  converterMap.put(RefProperty.class, new RefPropertyConverter());
  converterMap.put(ArrayProperty.class, new ArrayPropertyConverter());
  converterMap.put(MapProperty.class, new MapPropertyConverter());
  converterMap.put(StringProperty.class, new StringPropertyConverter());
  converterMap.put(ObjectProperty.class, new ObjectPropertyConverter());

  converterMap.put(ModelImpl.class, new ModelImplConverter());
  converterMap.put(RefModel.class, new RefModelConverter());
  converterMap.put(ArrayModel.class, new ArrayModelConverter());

  converterMap.put(BodyParameter.class, new BodyParameterConverter());

  AbstractSerializableParameterConverter converter = new AbstractSerializableParameterConverter();
  converterMap.put(QueryParameter.class, converter);
  converterMap.put(PathParameter.class, converter);
  converterMap.put(HeaderParameter.class, converter);
  converterMap.put(FormParameter.class, converter);
  converterMap.put(CookieParameter.class, converter);
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
private static Parameter createParameterInstance(ApiImplicitParam paramAnnotation) {
  switch (paramAnnotation.paramType()) {
    case "path":
      return new PathParameter();
    case "query":
      return new QueryParameter();
    case "body":
      return new BodyParameter();
    case "header":
      return new HeaderParameter();
    case "form":
      return new FormParameter();
    case "cookie":
      return new CookieParameter();
    default:
      throw new Error("not support paramType " + paramAnnotation.paramType());
  }
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
@Test
public void testUrlPathBuilder() throws Exception {
  Map<String, RestParam> paramMap = new HashMap<>();

  Parameter pathParameter = new PathParameter();
  pathParameter.setName("id");
  RestParam oRestParam = new RestParam(0, pathParameter, int.class);
  paramMap.put(oRestParam.getParamName(), oRestParam);

  Parameter queryParameter = new QueryParameter();
  queryParameter.setName("q");
  oRestParam = new RestParam(1, queryParameter, String.class);
  paramMap.put(oRestParam.getParamName(), oRestParam);

  URLPathBuilder oURLPathBuilder = new URLPathBuilder("/root/{id}", paramMap);
  Object[] args = new Object[] {100, "query"};
  Assert.assertEquals("/root/100?q=query", oURLPathBuilder.createRequestPath(args));
  Assert.assertEquals("/root/100", oURLPathBuilder.createPathString(args));
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
public Result validatePath(ResourcePath path, boolean strict) throws ValidationException {
    Result result = new Result();
    ResourcePath swaggerPath = getSwaggerRequest().getPath();
    if (strict) {
        // validate path segments
        if (swaggerPath.getSegments().length < path.getSegments().length) {
            String unknownPath = "";
            for (int i = swaggerPath.getSegments().length; i < path.getSegments().length; i++)
                unknownPath += "/" + path.getSegment(i);
            result.also(Status.BAD_REQUEST, "Unknown path suffix: " + unknownPath);
        }
    }
    List<PathParameter> pathParams = getSwaggerRequest().getPathParameters();
    for (int i = 0; i < pathParams.size(); i++) {
        PathParameter pathParam = pathParams.get(i);
        for (ParameterValidator<? extends Parameter> validator : parameterValidators.getValidators(pathParam)) {
            result.also(validator.doValidate(getSwaggerRequest(), pathParam, path.getSegment(i), strict));
        }
    }
    return result;
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
@Test
public void map_ReturnsEmptyMap_WhenParameterHasNoParameterInputVendorExtension() {
  // Arrange
  Operation operation = new Operation();
  PathParameter pathParameter = new PathParameter();

  pathParameter.setVendorExtension("x-dotwebstack-another-vendor-extension",
      parameter.getIdentifier().stringValue());
  operation.setParameters(ImmutableList.of(pathParameter));

  // Act
  Map<String, String> result = mapper.map(operation, product, requestParameters);

  // Assert
  assertThat(result.isEmpty(), is(true));
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
@Test
public void map_ThrowsException_ForUnknownParameterName() {
  // Assert
  thrown.expect(ConfigurationException.class);
  thrown.expectMessage("No parameter found for vendor extension value:");

  // Arrange
  Operation operation = new Operation();
  PathParameter parameter = new PathParameter();

  parameter.setVendorExtension(OpenApiSpecificationExtensions.PARAMETER, "http://unknown");
  operation.setParameters(ImmutableList.of(parameter));

  // Act
  mapper.map(operation, product, requestParameters);
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
@Test
public void testFillPathStringParameter() {
	for (int i = 0; i < 100; i++) {
		SwagRequest request = new SwagRequest();

		PathParameter param = new PathParameter();
		param.setIn("path");
		param.setType("string");
		param.setFormat("date");
		param.setName("testParam");
		param.setRequired(true);

		ParameterGenerator.fillParameter(swagger.getSwagger(), request, param, TestType.VALID);

		assertNotNull(request.getPathParameters());
		assertEquals(1, request.getPathParameters().size());
		assertTrue(request.getPathParameters().containsKey("testParam"));
		assertTrue(request.getPathParameters().get("testParam") instanceof String);
	}
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
private static Parameter getParameter(Map.Entry<String, Boolean> parameterEntry) {
	Parameter parameter;
	String parameterName = parameterEntry.getKey();
	if (parameterName.startsWith(METHOD_REQUEST_PATH)) {
		parameter = new PathParameter()
				.name(parameterName.substring(METHOD_REQUEST_PATH.length()))
				.type("string"); 	//There is no type information for params in API gateway
	} else if (parameterName.startsWith(METHOD_REQUEST_QUERYSTRING)) {
		parameter = new QueryParameter() 
				.name(parameterName.substring(METHOD_REQUEST_QUERYSTRING.length()))
				.type("string");
	} else if (parameterName.startsWith(METHOD_REQUEST_HEADER)) {
		parameter = new HeaderParameter()
				.name(parameterName.substring(METHOD_REQUEST_HEADER.length()))
				.type("string");
	} else {
		throw new UnsupportedOperationException("Unsupported request parameter type " + parameterName);
	}
	parameter.setRequired(parameterEntry.getValue());
	return parameter;
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
@Test
public void testCreate() {
  ParamValueProcessorCreator creator =
      ParamValueProcessorCreatorManager.INSTANCE.findValue(PathProcessorCreator.PARAMTYPE);
  Parameter parameter = new PathParameter();
  parameter.setName("path");

  ParamValueProcessor processor = creator.create(parameter, String.class);

  Assert.assertEquals(PathProcessor.class, processor.getClass());
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
protected void addDefaultValidators() {
    addValidator(StringProperty.class, new StringPropertyValidator());
    addValidator(AbstractNumericProperty.class, new NumberPropertyValidator());
    addValidator(PathParameter.class, new PathParameterValidator());
    addValidator(QueryParameter.class, new QueryParameterValidator());
    addValidator(HeaderParameter.class, new HeaderParameterValidator());
    addValidator(BodyParameter.class, new BodyParameterValidator(propertyValidators));
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
public List<PathParameter> getPathParameters() {
    List<PathParameter> pathParams = new ArrayList<>();
    for (Parameter param : getParameters()) {
        if (param instanceof PathParameter)
            pathParams.add((PathParameter)param);
    }
    return pathParams;
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
private Parameter paramId() {
    PathParameter res = new PathParameter();
    res.setName(PARAM_NAME_ID);
    res.setRequired(true);
    res.setType(StringProperty.TYPE);
    return res;
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
private Parameter paramPath(RequestRouter.Parameter routeParam) {
    PathParameter pathParam = new PathParameter();
    pathParam.setName(routeParam.name);
    pathParam.setDescription(routeParam.description);
    pathParam.setRequired(routeParam.required);
    // Setting the type to be lowercase so that we match the swagger type.
    pathParam.setType(routeParam.type != null ? routeParam.type.toLowerCase() : "");
    pathParam.setDefaultValue(routeParam.value);
    return pathParam;
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
@Test
public void map_ReturnsCorrectParameterName_ForPathParameters() {
  // Arrange
  PathParameter pathParameter = new PathParameter();

  pathParameter.setName("param1");
  pathParameter.setIn("path");

  // Note this parameter has multiple vendor extensions
  pathParameter.setVendorExtension(OpenApiSpecificationExtensions.PARAMETER,
      parameter.getIdentifier().stringValue());
  pathParameter.setVendorExtension("x-dotwebstack-another-vendor-extension", "foo");

  // Note this operation has multiple parameters
  Operation operation = new Operation();
  operation.addParameter(pathParameter);

  PathParameter pathParameter2 = new PathParameter();

  pathParameter2.setName("param2");
  pathParameter2.setIn("path");
  pathParameter2.setVendorExtension(OpenApiSpecificationExtensions.PARAMETER,
      parameter2.getIdentifier().stringValue());

  operation.addParameter(pathParameter2);

  MultivaluedMap<String, String> pathParameters = new MultivaluedHashMap<>();

  // Note there are multiple values for this parameter, to test that the first value is used only
  pathParameters.put(pathParameter.getName(), ImmutableList.of("value", "valueB"));
  pathParameters.put(pathParameter2.getName(), ImmutableList.of("value2"));

  // Act
  Map<String, String> result = mapper.map(operation, product, requestParameters);

  // Assert
  assertThat(result.size(), is(2));
  assertThat(result, hasEntry(parameter.getName(), "value"));
  assertThat(result, hasEntry(parameter2.getName(), "value2"));
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
private PathParameter buildPathParameter(VariableElement variableElement, PathVariable pathVariable) {
    Property property = ofNullable(propertyUtils.toSimpleProperty(variableElement))
            .filter(prop -> !(prop instanceof ObjectProperty))
            .orElseGet(StringProperty::new);
    return new PathParameter()
            .name(pathVariable.value())
            .required(true)
            .property(property);
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
private Parameter createParam(String paramType) {
    if ("path".equals(paramType))
        return new PathParameter();
    else if ("query".equals(paramType))
        return new QueryParameter();
    else if ("form".equals(paramType))
        return new FormParameter();
    else if ("formData".equals(paramType))
        return new FormParameter();
    else if ("header".equals(paramType))
        return new HeaderParameter();
    else if ("body".equals(paramType))
        return new BodyParameter();
    return null;
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
public static String getURL(Operation operation, String baseUrl) {
	URIBuilder builder = new URIBuilder();
	List<Parameter> paramList = operation.getParameters();
	String url = baseUrl;
	for (Parameter parameter : paramList) {
		if (parameter.getRequired() && parameter instanceof QueryParameter) {
			QueryParameter qp = (QueryParameter) parameter;

			if (Variables.APIKEY.equals(parameter.getName())) {
				builder.setParameter(parameter.getName(), System.getenv("APIKEY"));
			} else {
				builder.setParameter(parameter.getName(), qp.getDefaultValue());
			}
		} else if (parameter instanceof PathParameter) {
			PathParameter pathParameter = (PathParameter) parameter;
			url = url.replace("{" + parameter.getName() + "}", pathParameter.getDefaultValue());
		}
	}
	builder.setPath(url);

	URI uri = null;
	try {
		uri = builder.build();

	} catch (URISyntaxException e) {

		logger.error(e);
	}

	HttpGet httpget = new HttpGet(uri);

	logger.info(httpget.getURI());
	return httpget.getURI().toString();
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
/**
 * @return the swagger PathParameter for this particular path segment.
 */
private Parameter getPathParameter() {
    String typeName = dictionary.getJsonAliasFor(type);

    Parameter param = new PathParameter()
            .name(typeName + "Id")
            .description(typeName + " Identifier")
            .property(new StringProperty());

    return param;
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
protected String addParameters(Operation operation, String path) {
    String queryString = null;
    if (path.contains("?")) {
        String[] parts = path.split("?");
        path = parts[0];
        queryString = parts[1];

    }

    path = addParameters(operation, path, PathParameter.class);
    addParameters(operation, queryString, QueryParameter.class);

    return path;
}
 

import io.swagger.models.parameters.PathParameter; //导入依赖的package包/类
@Override
protected PathParameter createParameter() {
  return new PathParameter();
}