AbstractSerializableParameter serializableParameter = (AbstractSerializableParameter) parameter; @SuppressWarnings("unchecked") List<String> enums = serializableParameter.getEnum(); type = new EnumType(serializableParameter.getName(), enums); } else { type = new BasicType(serializableParameter.getType(), serializableParameter.getName(), serializableParameter.getFormat()); if (serializableParameter.getType().equals("array")) { String collectionFormat = serializableParameter.getCollectionFormat(); type = new ArrayType(serializableParameter.getName(), new PropertyAdapter(serializableParameter.getItems()).getType(definitionDocumentResolver), collectionFormat);
((AbstractSerializableParameter<?>) parameter).setDefaultValue(defaultValue); } else if ((((AbstractSerializableParameter<?>) parameter).getDefaultValue() == null) && (!((AbstractSerializableParameter<?>) parameter) .getRequired())) { //if required false then only take java primitive values as defaults if (parameterType instanceof Class && ((Class) parameterType).isPrimitive()) { switch (parameterType.getTypeName()) { ((AbstractSerializableParameter<?>) parameter).setDefaultValue(defaultValue);
private AbstractSerializableParameter<?> createSimpleParam(Entry<String, Property> propertyEntry) { AbstractSerializableParameter<?> newParameter = new QueryParameter(); newParameter.setName(propertyEntry.getKey()); newParameter.setProperty(propertyEntry.getValue()); return newParameter; } }
/** * Generate a default example value for parameter. * * @param parameter parameter * @return a generated example for the parameter */ public static Object generateExample(AbstractSerializableParameter<?> parameter) { switch (parameter.getType()) { case "integer": return 0; case "number": return 0.0; case "boolean": return true; case "string": return ExamplesUtil.generateStringExample(parameter.getFormat(), parameter.getEnum()); default: return parameter.getType(); } }
if (generateMissingExamples) { Object abstractSerializableParameterExample; abstractSerializableParameterExample = ((AbstractSerializableParameter) parameter).getExample(); if (abstractSerializableParameterExample == null) { abstractSerializableParameterExample = parameter.getVendorExtensions().get("x-example"); Property item = ((AbstractSerializableParameter) parameter).getItems(); if (item != null) { abstractSerializableParameterExample = item.getExample();
private static void copyFields(AbstractSerializableParameter<?> from, AbstractSerializableParameter<?> to) { copyFields((AbstractParameter) from, (AbstractParameter) to); to.setCollectionFormat(from.getCollectionFormat()); to.setDefault(from.getDefault()); to.setEnum(from.getEnum()); if (from.getExample() != null) { to.setExample(from.getExample().toString()); } to.setExclusiveMaximum(to.isExclusiveMaximum()); to.setExclusiveMinimum(to.isExclusiveMinimum()); to.setFormat(from.getFormat()); to.setItems(from.getItems()); to.setMaximum(from.getMaximum()); to.setMaxItems(from.getMaxItems()); to.setMaxLength(from.getMaxLength()); to.setMinLength(to.getMinLength()); to.setMinimum(from.getMinimum()); to.setMaxItems(from.getMaxItems()); to.setMinLength(from.getMinLength()); to.setMultipleOf(from.getMultipleOf()); to.setType(from.getType()); to.setUniqueItems(from.isUniqueItems()); }
p.setRequired(true); p.setName(param.getName()); p.setDescription(param.getDescription()); p.setAccess(param.getAccess()); p.setType(param.getDataType()); if (p.getItems() != null || param.isAllowMultiple()) { if (p.getItems() == null) { args.put(PropertyBuilder.PropertyId.DEFAULT, p.getDefaultValue()); p.setDefaultValue(null); args.put(PropertyBuilder.PropertyId.ENUM, p.getEnum()); p.setEnum(null); args.put(PropertyBuilder.PropertyId.MINIMUM, p.getMinimum()); p.setMinimum(null); args.put(PropertyBuilder.PropertyId.EXCLUSIVE_MINIMUM, p.isExclusiveMinimum()); p.setExclusiveMinimum(null); args.put(PropertyBuilder.PropertyId.MAXIMUM, p.getMaximum()); p.setMaximum(null); args.put(PropertyBuilder.PropertyId.EXCLUSIVE_MAXIMUM, p.isExclusiveMaximum()); p.setExclusiveMaximum(null); Property items = PropertyBuilder.build(p.getType(), p.getFormat(), args); p.type(ArrayProperty.TYPE).format(null).items(items); PropertyBuilder.merge(p.getItems(), args);
switch (attr) { case "collectionFormat": _switchResult = param.getCollectionFormat(); break; case "defaultValue": _switchResult = param.getDefaultValue(); break; case "enum": _switchResult = param.getEnum(); break; case "format": _switchResult = param.getFormat(); break; case "items": _switchResult = param.getItems(); break; case "maxItems": _switchResult = param.getMaxItems(); break; case "maxLength": break; case "maximum": _switchResult = param.getMaximum(); break; case "minItems": _switchResult = param.getMinItems(); break; case "minLength":
final Object defaultValue = serializableParameter.getDefaultValue(); if (defaultValue != null) { propertyBuilder.defaultValue(String.valueOf(defaultValue)); final String type = serializableParameter.getType(); propertyBuilder.type(type).javaType(JsonSchemaHelper.javaTypeFor(serializableParameter)); final List<String> enums = serializableParameter.getEnum(); if (enums != null) { propertyBuilder.addAllEnum(createEnums(enums));
@Override public JavaType convert(SwaggerToClassGenerator swaggerToClassGenerator, Object def) { AbstractSerializableParameter<?> param = (AbstractSerializableParameter<?>) def; switch (param.getType()) { case ArrayProperty.TYPE: return ArrayPropertyConverter.findJavaType(swaggerToClassGenerator, param.getItems(), param.isUniqueItems()); case StringProperty.TYPE: return StringPropertyConverter.findJavaType(swaggerToClassGenerator, param.getType(), param.getFormat(), param.getEnum()); default: return ConverterMgr.findJavaType(param.getType(), param.getFormat()); } } }
final String type = serializableParameter.getType(); final String name = trimToNull(serializableParameter.getName()); final String description = trimToNull(serializableParameter.getDescription()); final Object defaultValue = serializableParameter.getDefault(); if (defaultValue != null) { parameterParameter.put("default", String.valueOf(defaultValue)); if (serializableParameter.getItems() != null) { final Property items = serializableParameter.getItems(); final List<String> enums = serializableParameter.getEnum();
final String type = serializableParameter.getType(); final String name = trimToNull(serializableParameter.getName()); final String description = trimToNull(serializableParameter.getDescription()); final Object defaultValue = serializableParameter.getDefault(); if (defaultValue != null) { parameterParameter.put("default", String.valueOf(defaultValue));
type = p.getType(); if (p.getType().equalsIgnoreCase("array")){ Property ap = p.getItems(); type = ap.getType(); type = SwaggerTypeManager.teiidType(type, p.getFormat(), p.getItems() != null); defaultValue = p.getDefaultValue(); collectionFormat = p.getCollectionFormat(); } else { throw new MetadataException("Unknown property type" + parameter.getClass().getName()); //$NON-NLS-1$
protected static void processApiParam(ApiParam param, AbstractSerializableParameter<?> p) { if (param.required()) { p.setRequired(true); p.setReadOnly(true); p.setAllowEmptyValue(true); p.setName(param.name()); p.setDescription(param.value()); p.setExample(param.example()); p.setAccess(param.access()); p.setCollectionFormat(param.collectionFormat()); p.setProperty(new FileProperty()); } else if ("long".equalsIgnoreCase(param.type())) { p.setProperty(new LongProperty()); } else { p.setType(param.type());
final String type = XmlSchemaHelper.toXsdType(serializableParameter.getType()); final String name = trimToNull(serializableParameter.getName()); final Object defaultValue = serializableParameter.getDefault(); if (defaultValue != null) { element.addAttribute("default", String.valueOf(defaultValue));
private static void addEnumsTo(final Element element, final AbstractSerializableParameter<?> serializableParameter) { if (serializableParameter.getItems() != null) { final Property items = serializableParameter.getItems(); List<?> enums; try { final Method method = ClassUtils.getPublicMethod(items.getClass(), "getEnum"); final List<?> tmp = (List<?>) method.invoke(items); enums = tmp; } catch (@SuppressWarnings("unused") final ReflectiveOperationException ignored) { enums = Collections.emptyList(); } if (enums != null && !enums.isEmpty()) { addEnumerationsTo(element, enums); } } else { final List<String> enums = serializableParameter.getEnum(); if (enums != null && !enums.isEmpty()) { addEnumerationsTo(element, enums); } } }
/** * Create validation expression using functions according to parameter type and format. * @param parameter * @return */ private String createValidationExpression(AbstractSerializableParameter parameter) { switch (parameter.getType()) { case "integer": return "@isNumber()@"; case "string": if (parameter.getFormat() != null && parameter.getFormat().equals("date")) { return "\"@matchesDatePattern('yyyy-MM-dd')@\""; } else if (parameter.getFormat() != null && parameter.getFormat().equals("date-time")) { return "\"@matchesDatePattern('yyyy-MM-dd'T'hh:mm:ss')@\""; } else if (StringUtils.hasText(parameter.getPattern())) { return "\"@matches(" + parameter.getPattern() + ")@\""; } else if (!CollectionUtils.isEmpty(parameter.getEnum())) { return "\"@matches(" + (parameter.getEnum().stream().collect(Collectors.joining("|"))) + ")@\""; } else { return "@notEmpty()@"; } case "boolean": return "@matches(true|false)@"; default: return "@ignore@"; } }
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); }
private Class<?> getType(String name, Parameter parameter) { checkNotNull(parameter, String.format("Could not find parameter [%s] in swagger model!", name)); if (parameter instanceof AbstractParameter) { AbstractSerializableParameter castedParam = (AbstractSerializableParameter) parameter; return Types.getParameterType(castedParam.getType(), castedParam.getFormat()); } else { throw new UnsupportedOperationException(String.format("Parameter type [%s] not supported!", parameter.getClass().getName())); } } }
private Parameter readParam(Swagger swagger, Type type,Class<?> cls, ApiParam param) { PrimitiveType fromType = PrimitiveType.fromType(type); final Parameter para = null == fromType ? new BodyParameter() : 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()); }else{ //hack: Get the from data model paramter from BodyParameter BodyParameter bp = (BodyParameter)parameter; bp.setIn("formData"); } return parameter; }