Java AbstractSerializableParameter类代码示例

import io.swagger.models.parameters.AbstractSerializableParameter; //导入依赖的package包/类
public static void setParameterType(Swagger swagger, Method method, int paramIdx,
    AbstractSerializableParameter<?> parameter) {
  Type paramType = ParamUtils.getGenericParameterType(method, paramIdx);

  ParamUtils.addDefinitions(swagger, paramType);

  Property property = ModelConverters.getInstance().readAsProperty(paramType);

  if (isComplexProperty(property)) {
    // 简单参数不可以是复杂类型
    String msg = String.format("not allow complex type for %s parameter, method=%s:%s, paramIdx=%d, type=%s",
        parameter.getIn(),
        method.getDeclaringClass().getName(),
        method.getName(),
        paramIdx,
        paramType.getTypeName());
    throw new Error(msg);
  }
  parameter.setProperty(property);
}
 

import io.swagger.models.parameters.AbstractSerializableParameter; //导入依赖的package包/类
@Override
public JavaType convert(ClassLoader classLoader, String packageName, Swagger swagger, Object def) {
  AbstractSerializableParameter<?> param = (AbstractSerializableParameter<?>) def;

  switch (param.getType()) {
    case ArrayProperty.TYPE:
      return ArrayPropertyConverter.findJavaType(classLoader,
          packageName,
          swagger,
          param.getItems(),
          param.isUniqueItems());
    case StringProperty.TYPE:
      return StringPropertyConverter.findJavaType(classLoader,
          packageName,
          swagger,
          param.getType(),
          param.getFormat(),
          param.getEnum());
    default:
      return ConverterMgr.findJavaType(param.getType(), param.getFormat());
  }
}
 

import io.swagger.models.parameters.AbstractSerializableParameter; //导入依赖的package包/类
@Override
public <T extends AbstractSerializableParameter<T>> List<ValidationError> validate(AbstractSerializableParameter<T> parameterDef, String value) {
    ImmutableList.Builder<ValidationError> errorsBuilder = ImmutableList.builder();
    ParameterSource parameterSource = ParameterSource.valueOf(parameterDef.getIn());
    String key = parameterDef.getName();

    if (parameterDef.getPattern() != null && !value.matches(parameterDef.getPattern())) {
        errorsBuilder.add(new ValidationError(parameterSource,
            key,
            Messages.validationMessage("err.common.pattern.noMatch", parameterDef.getPattern(), value))
        );
    }

    if (parameterDef.getMinLength() != null && value.length() < parameterDef.getMinLength()) {
        errorsBuilder.add(new ValidationError(parameterSource,
            key,
            Messages.validationMessage("err.common.minLength.tooShort", value, value.length(), parameterDef.getMinLength()))
        );
    }

    if (parameterDef.getMaxLength() != null && value.length() > parameterDef.getMaxLength()) {
        errorsBuilder.add(new ValidationError(parameterSource,
            key,
            Messages.validationMessage("err.common.maxLength.tooLong", value, value.length(), parameterDef.getMaxLength()))
        );
    }

    return errorsBuilder.build();
}
 

import io.swagger.models.parameters.AbstractSerializableParameter; //导入依赖的package包/类
private static void processAllowedValues(AllowableValues allowableValues, AbstractSerializableParameter<?> p) {
    if (allowableValues == null) {
        return;
    }
    Map<PropertyBuilder.PropertyId, Object> args = allowableValues.asPropertyArguments();
    if (args.containsKey(PropertyBuilder.PropertyId.ENUM)) {
        p.setEnum((List<String>) args.get(PropertyBuilder.PropertyId.ENUM));
    } else {
        if (args.containsKey(PropertyBuilder.PropertyId.MINIMUM)) {
            p.setMinimum((BigDecimal) args.get(PropertyBuilder.PropertyId.MINIMUM));
        }
        if (args.containsKey(PropertyBuilder.PropertyId.MAXIMUM)) {
            p.setMaximum((BigDecimal) args.get(PropertyBuilder.PropertyId.MAXIMUM));
        }
        if (args.containsKey(PropertyBuilder.PropertyId.EXCLUSIVE_MINIMUM)) {
            p.setExclusiveMinimum((Boolean) args.get(PropertyBuilder.PropertyId.EXCLUSIVE_MINIMUM) ? true : null);
        }
        if (args.containsKey(PropertyBuilder.PropertyId.EXCLUSIVE_MAXIMUM)) {
            p.setExclusiveMaximum((Boolean) args.get(PropertyBuilder.PropertyId.EXCLUSIVE_MAXIMUM) ? true : null);
        }
    }
}
 

import io.swagger.models.parameters.AbstractSerializableParameter; //导入依赖的package包/类
public static String getDefaultValue(Parameter parameter){
    Validate.notNull(parameter, "property must not be null!");
    String defaultValue = "";
    if(parameter instanceof AbstractSerializableParameter){
        AbstractSerializableParameter serializableParameter = (AbstractSerializableParameter)parameter;
        defaultValue = serializableParameter.getDefaultValue();
        if(defaultValue == null || defaultValue.isEmpty()) {
            switch (serializableParameter.getType()) {
                case "string":
                    return "\"str\"";
                case "integer":
                    return "0";
                default:
                    return "";
            }
        }
    }

    return StringUtils.defaultString(defaultValue);
}
 

import io.swagger.models.parameters.AbstractSerializableParameter; //导入依赖的package包/类
private String getValue(AbstractSerializableParameter value)
{
    switch (value.getType()) {
        case "date":
            return "\"2015-01-20\"";
        case "string":
            return "\"str\"";
        case "integer":
        case "long":
            return "0";
        case "double":
            return "0.0";
        case "boolean":
            return "false";
        case "map":
            return "{\"prop\": value}";
        case "array":
            return "[\n\t" + getValue(value.getItems()) + "\n]";
        default:
            return "";
    }
}
 

import io.swagger.models.parameters.AbstractSerializableParameter; //导入依赖的package包/类
private SerializableParameter complement(Property property, RouteParameter source,
    SerializableParameter param) {
  param.setType(property.getType());
  param.setFormat(property.getFormat());
  // array param:
  if (property instanceof ArrayProperty) {
    param.setItems(((ArrayProperty) property).getItems());
  }
  // enum values:
  List<String> enums = source.enums();
  if (enums.size() > 0) {
    param.setEnum(enums);
  }
  // default value:
  if (param instanceof AbstractSerializableParameter) {
    ((AbstractSerializableParameter) param).setDefault(source.defaultValue());
  }
  return param;
}
 

import io.swagger.models.parameters.AbstractSerializableParameter; //导入依赖的package包/类
private Parameter readParam(Swagger swagger, Type type,Class<?> cls, ApiParam param) {
	PrimitiveType fromType = PrimitiveType.fromType(type);
	final Parameter para = null == fromType ? new FormParameter() : new QueryParameter();
	Parameter parameter = ParameterProcessor.applyAnnotations(swagger, para,
			type == null ? String.class : type, null == param ? new ArrayList<Annotation>()
					: Collections.<Annotation> singletonList(param));
	if (parameter instanceof AbstractSerializableParameter) {
		final AbstractSerializableParameter<?> p = (AbstractSerializableParameter<?>) parameter;
		if (p.getType() == null) p.setType(null == fromType ? "string" : fromType.getCommonName());
		p.setRequired(p.getRequired() == true ? true : cls.isPrimitive());
	}
	return parameter;
}
 

import io.swagger.models.parameters.AbstractSerializableParameter; //导入依赖的package包/类
public Object extract(String name, Parameter parameter, MultiMap params) {
    AbstractSerializableParameter abstractSerializableParameter = (AbstractSerializableParameter) parameter;
    if (!params.contains(name)) {
        if (abstractSerializableParameter.getRequired()) {
            throw new IllegalArgumentException("Missing required parameter: " + name);
        } else if (abstractSerializableParameter.getDefaultValue()!=null){
            return abstractSerializableParameter.getDefaultValue();
        } else {
            return null;
        }
    }

    if ((abstractSerializableParameter.getAllowEmptyValue() == null
            || !abstractSerializableParameter.getAllowEmptyValue())
            && StringUtils.isEmpty(params.get(name))) {
        throw new IllegalArgumentException(
                "Empty value is not authorized for parameter: " + name);
    }

    if ("array".equals(abstractSerializableParameter.getType())) {
        if ("multi".equals(abstractSerializableParameter.getCollectionFormat())) {
            return params.getAll(name);
        } else {
            List<String> resultParams = this.splitArrayParam(abstractSerializableParameter,
                    params.get(name));
            if (resultParams != null) {
                return resultParams;
            }
        }
    }

    return params.get(name);
}
 

import io.swagger.models.parameters.AbstractSerializableParameter; //导入依赖的package包/类
@Override
public <T extends AbstractSerializableParameter<T>> List<ValidationError> validateParam(AbstractSerializableParameter<?> parameterDef, String value) {
    DateTimeFormatter dateFormatter = getFormatter();
    try {
        dateFormatter.parse(value);
    } catch (DateTimeParseException e) {
        return singletonList(
            ValidationError.forParameter(parameterDef, Messages.validationMessage("err.format.invalidDate", value, getFormatString()))
        );
    }

    return emptyList();
}
 

import io.swagger.models.parameters.AbstractSerializableParameter; //导入依赖的package包/类
@Override
public <T extends AbstractSerializableParameter<T>> List<ValidationError> validate(AbstractSerializableParameter<T> parameterDef, String value) {
    ImmutableList.Builder<ValidationError> errorsBuilder = ImmutableList.builder();

    try {
        N convertedValue = convert(value);
        errorsBuilder.addAll(validateRange(parameterDef, convertedValue.doubleValue()));
    } catch (NumberFormatException ce) {
        errorsBuilder.add(
            ValidationError.forParameter(parameterDef, "input string \"" + value + "\" is not a valid " + parameterDef.getFormat())
        );
    }

    return errorsBuilder.build();
}
 

import io.swagger.models.parameters.AbstractSerializableParameter; //导入依赖的package包/类
private <T extends AbstractSerializableParameter<T>> List<ValidationError> validateRange(AbstractSerializableParameter<T> parameterDef, double value) {
    ImmutableList.Builder<ValidationError> errorsBuilder = ImmutableList.builder();

    Double maximum = parameterDef.getMaximum();
    boolean exclusiveMaximum = firstNonNull(parameterDef.isExclusiveMaximum(), false);
    Double minimum = parameterDef.getMinimum();
    boolean exclusiveMinimum = firstNonNull(parameterDef.isExclusiveMinimum(), false);

    if (maximum != null) {
        if (!exclusiveMaximum && value > maximum) {
            errorsBuilder.add(ValidationError.forParameter(parameterDef,
                validationMessage("err.common.maximum.notExclusive", maximum, value))
            );
        } else if (exclusiveMaximum && value >= maximum) {
            errorsBuilder.add(ValidationError.forParameter(parameterDef,
                validationMessage("err.common.maximum.tooLarge", maximum, value))
            );
        }
    }

    if (minimum != null) {
        if (!exclusiveMinimum && value < minimum) {
            errorsBuilder.add(ValidationError.forParameter(parameterDef,
                validationMessage("err.common.minimum.notExclusive", minimum, value))
            );
        } else if (exclusiveMinimum && value <= minimum) {
            errorsBuilder.add(ValidationError.forParameter(parameterDef,
                validationMessage("err.common.minimum.tooSmall", minimum, value))
            );
        }
    }


    return errorsBuilder.build();
}
 

import io.swagger.models.parameters.AbstractSerializableParameter; //导入依赖的package包/类
@Override
public <T extends AbstractSerializableParameter<T>> List<ValidationError> validateParam(AbstractSerializableParameter<?> parameterDef, String value) {
    ImmutableList.Builder<ValidationError> errorsBuilder = ImmutableList.builder();

    errorsBuilder.addAll(validateGenericRules(parameterDef, value));
    errorsBuilder.addAll(validate(parameterDef, value));

    return errorsBuilder.build();
}
 

import io.swagger.models.parameters.AbstractSerializableParameter; //导入依赖的package包/类
private <T extends AbstractSerializableParameter<T>> List<ValidationError> validateGenericRules(AbstractSerializableParameter<T> parameterDef, String value) {
    if (parameterDef.getEnum() != null && !parameterDef.getEnum().contains(value)) {
        return Collections.singletonList(
            ValidationError.forParameter(parameterDef, Messages.validationMessage("err.common.enum.notInEnum", value, parameterDef.getEnum()))
        );
    }

    return emptyList();
}
 

import io.swagger.models.parameters.AbstractSerializableParameter; //导入依赖的package包/类
@Override
public <T extends AbstractSerializableParameter<T>> List<ValidationError> validate(AbstractSerializableParameter<T> parameterDef, String value) {
    if (!value.equals("true") && !value.equals("false")) {
        return Collections.singletonList(
            ValidationError.forParameter(parameterDef, String.format("string \"%s\" is not a valid boolean", value))
        );
    }

    return emptyList();
}