public String getName() { return parameter.getName(); }
public ParameterAdapter(Swagger2MarkupConverter.Context context, PathOperation operation, Parameter parameter, DocumentResolver definitionDocumentResolver) { Validate.notNull(parameter, "parameter must not be null"); this.parameter = parameter; type = getType(context.getSwagger().getDefinitions(), definitionDocumentResolver); config = context.getConfig(); if (config.isInlineSchemaEnabled()) { if (config.isFlatBodyEnabled()) { if (!(type instanceof ObjectType)) { type = InlineSchemaUtils.createInlineType(type, parameter.getName(), operation.getId() + " " + parameter.getName(), inlineDefinitions); } } else { type = InlineSchemaUtils.createInlineType(type, parameter.getName(), operation.getId() + " " + parameter.getName(), inlineDefinitions); } } }
example = parameter.getName() +":\"" +((HeaderParameter) parameter).getType()+ "\""; } else if (parameter instanceof PathParameter) { String pathExample = (String) examples.get("path"); pathExample = pathExample.replace('{' + parameter.getName() + '}', encodeExampleForUrl(abstractSerializableParameterExample)); example = pathExample; } else if (parameter instanceof QueryParameter) { String pathExample = path + separator + parameter.getName() + "=" + encodeExampleForUrl(abstractSerializableParameterExample); examples.put("path", pathExample);
typeInfos.italicText(labels.getLabel(NAME_COLUMN)).textLine(COLON + parameter.getName()); typeInfos.italicText(labels.getLabel(FLAGS_COLUMN)).textLine(COLON + (BooleanUtils.isTrue(parameter.getRequired()) ? labels.getLabel(FLAGS_REQUIRED).toLowerCase() : labels.getLabel(FLAGS_OPTIONAL).toLowerCase()));
public static int findParameterByName(String name, List<Parameter> parameterList) { for (int idx = 0; idx < parameterList.size(); idx++) { Parameter parameter = parameterList.get(idx); if (name.equals(parameter.getName())) { return idx; } } return -1; }
/** * Add a parameter into {@linkplain #providerParameters}, * duplicated name params will be ignored(excepting for {@linkplain ContextParameter}s) */ public void addProviderParameter(Parameter parameter) { if (ContextParameter.class.isInstance(parameter)) { // ContextParameter has no name and is not written in schema, // so just add it without checking providerParameters.add(parameter); return; } // check duplicated param according to param name for (Parameter providerParameter : providerParameters) { if (parameter.getName().equals(providerParameter.getName())) { LOGGER.warn( "Param name [{}] is duplicated which may cause ambiguous deserialization result. Please check you schema definition", parameter.getName()); return; } } providerParameters.add(parameter); }
public RestParam(int paramIndex, Parameter parameter, Type genericParamType) { this.paramIndex = paramIndex; this.paramName = parameter.getName(); init(parameter, genericParamType); }
private void createWrapArgs(String wrapName, List<Parameter> parameters) { Map<String, Object> properties = new LinkedHashMap<>(); for (Parameter parameter : parameters) { properties.put(parameter.getName(), parameter); } createMessage(wrapName, properties, ProtoConst.ANNOTATION_WRAP_ARGUMENTS); }
public String getParamName(int idx) { return swaggerOperation.getParameters().get(idx).getName(); }
protected void copyToSwaggerParameters() { for (Parameter parameter : providerParameters) { if (ContextParameter.class.isInstance(parameter)) { continue; } int annotationIdx = ParamUtils.findParameterByName(parameter.getName(), methodAnnotationParameters); if (annotationIdx != -1) { Parameter annotationParameter = methodAnnotationParameters.remove(annotationIdx); swaggerParameters.add(annotationParameter); continue; } swaggerParameters.add(parameter); } swaggerParameters.addAll(methodAnnotationParameters); }
@Override public ParamValueProcessor create(Parameter parameter, Type genericParamType) { JavaType targetType = TypeFactory.defaultInstance().constructType(genericParamType); return new PathProcessor(parameter.getName(), targetType, ((PathParameter) parameter).getDefaultValue(), true); } }
protected void replaceBodyBasedParameter(OperationGenerator operationGenerator, Parameter bodyBasedParameter) { if (ParamUtils.isRealBodyParameter(bodyBasedParameter)) { return; } List<Parameter> swaggerParameters = operationGenerator.getSwaggerParameters(); int idx = swaggerParameters.indexOf(bodyBasedParameter); String bodyParamName = bodyBasedParameter.getName(); BodyParameter bodyParameter = ((PendingBodyParameter) bodyBasedParameter).createBodyParameter(bodyParamName); swaggerParameters.set(idx, bodyParameter); }
@Override public ParamValueProcessor create(Parameter parameter, Type genericParamType) { JavaType targetType = TypeFactory.defaultInstance().constructType(genericParamType); return new CookieProcessor(parameter.getName(), targetType, ((CookieParameter) parameter).getDefaultValue(), parameter.getRequired()); } }
@Override public ParamValueProcessor create(Parameter parameter, Type genericParamType) { JavaType targetType = TypeFactory.defaultInstance().constructType(genericParamType); return new HeaderProcessor(parameter.getName(), targetType, ((HeaderParameter) parameter).getDefaultValue(), parameter.getRequired()); } }
/** * Returns true when the swagger object already contains a common parameter * with the same name and type as the passed parameter. * * @param parameter The parameter to check. * @return true if the swagger object already contains a common parameter with the same name and type */ private boolean hasCommonParameter(Parameter parameter) { Parameter commonParameter = swagger.getParameter(parameter.getName()); return commonParameter != null && parameter.getIn().equals(commonParameter.getIn()); }
protected void updateOperationParameters(List<Parameter> parentParameters, Map<String, String> regexMap, Operation operation) { if (parentParameters != null) { for (Parameter param : parentParameters) { operation.parameter(param); } } for (Parameter param : operation.getParameters()) { String pattern = regexMap.get(param.getName()); if (pattern != null) { param.setPattern(pattern); } } }
@Override public ParamValueProcessor create(Parameter parameter, Type genericParamType) { QueryParameter queryParameter = (QueryParameter) parameter; JavaType targetType = TypeFactory.defaultInstance().constructType(genericParamType); return new QueryProcessor(parameter.getName(), targetType, queryParameter.getDefaultValue(), parameter.getRequired(), queryParameter.getCollectionFormat()); } }
@Override public ParamValueProcessor create(Parameter parameter, Type genericParamType) { JavaType targetType = TypeFactory.defaultInstance().constructType(genericParamType); if (isPart(parameter)) { return new PartProcessor(parameter.getName(), targetType, ((FormParameter) parameter).getDefaultValue(), parameter.getRequired()); } return new FormProcessor(parameter.getName(), targetType, ((FormParameter) parameter).getDefaultValue(), parameter.getRequired()); }
protected Map<String, ParamWrapper<Parameter>> getSwaggerParamMap(ArgumentsMapperConfig config) { Map<String, ParamWrapper<Parameter>> swaggerParamMap = new HashMap<>(); if (null == config.getSwaggerOperation() || null == config.getSwaggerOperation().getParameters()) { return swaggerParamMap; } List<Parameter> parameters = config.getSwaggerOperation().getParameters(); for (int i = 0; i < parameters.size(); i++) { Parameter parameter = parameters.get(i); swaggerParamMap.put(parameter.getName(), new ParamWrapper<>(parameter).setIndex(i)); } return swaggerParamMap; }
@Override public void process(Object annotation, SwaggerGenerator swaggerGenerator) { ApiImplicitParam paramAnnotation = (ApiImplicitParam) annotation; Parameter parameter = AnnotationUtils.createParameter(swaggerGenerator.getSwagger(), paramAnnotation); swaggerGenerator.getSwagger().addParameter(parameter.getName(), parameter); } }