use of org.apache.flink.shaded.jackson2.com.fasterxml.jackson.annotation.JsonProperty in project pinpoint by naver.
the class TransactionInfoViewModel method getCallStack.
@JsonProperty("callStack")
public List<CallStack> getCallStack() {
List<CallStack> list = new ArrayList<CallStack>();
boolean first = true;
long barRatio = 0;
for (Record record : recordSet.getRecordList()) {
if (first) {
if (record.isMethod()) {
long begin = record.getBegin();
long end = record.getBegin() + record.getElapsed();
if (end - begin > 0) {
barRatio = 100 / (end - begin);
}
}
first = false;
}
list.add(new CallStack(record, barRatio));
}
return list;
}
use of org.apache.flink.shaded.jackson2.com.fasterxml.jackson.annotation.JsonProperty in project druid by druid-io.
the class JsonConfigurator method configurate.
public <T> T configurate(Properties props, String propertyPrefix, Class<T> clazz, @Nullable Class<? extends T> defaultClass) throws ProvisionException {
verifyClazzIsConfigurable(jsonMapper, clazz, defaultClass);
// Make it end with a period so we only include properties with sub-object thingies.
final String propertyBase = propertyPrefix.endsWith(".") ? propertyPrefix : propertyPrefix + ".";
Map<String, Object> jsonMap = new HashMap<>();
for (String prop : props.stringPropertyNames()) {
if (prop.startsWith(propertyBase)) {
final String propValue = props.getProperty(prop);
Object value;
try {
// If it's a String Jackson wants it to be quoted, so check if it's not an object or array and quote.
String modifiedPropValue = propValue;
if (!(modifiedPropValue.startsWith("[") || modifiedPropValue.startsWith("{"))) {
modifiedPropValue = jsonMapper.writeValueAsString(propValue);
}
value = jsonMapper.readValue(modifiedPropValue, Object.class);
} catch (IOException e) {
// Do not log exception message or the property value as it might
// expose sensitive information
log.info("Unable to parse value of property [%s] as a json object, using as is.", prop);
value = propValue;
}
hieraricalPutValue(propertyPrefix, prop, prop.substring(propertyBase.length()), value, jsonMap);
}
}
final T config;
try {
if (defaultClass != null && jsonMap.isEmpty()) {
// No configs were provided. Don't use the jsonMapper; instead create a default instance of the default class
// using the no-arg constructor. We know it exists because verifyClazzIsConfigurable checks for it.
config = defaultClass.getConstructor().newInstance();
} else {
config = jsonMapper.convertValue(jsonMap, clazz);
}
} catch (IllegalArgumentException e) {
throw new ProvisionException(StringUtils.format("Problem parsing object at prefix[%s]: %s.", propertyPrefix, e.getMessage()), e);
} catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
throw new ProvisionException(StringUtils.format("Problem instantiating object at prefix[%s]: %s: %s.", propertyPrefix, e.getClass().getSimpleName(), e.getMessage()), e);
}
final Set<ConstraintViolation<T>> violations = validator.validate(config);
if (!violations.isEmpty()) {
List<String> messages = new ArrayList<>();
for (ConstraintViolation<T> violation : violations) {
StringBuilder path = new StringBuilder();
try {
Class<?> beanClazz = violation.getRootBeanClass();
final Iterator<Path.Node> iter = violation.getPropertyPath().iterator();
while (iter.hasNext()) {
Path.Node next = iter.next();
if (next.getKind() == ElementKind.PROPERTY) {
final String fieldName = next.getName();
final Field theField = beanClazz.getDeclaredField(fieldName);
if (theField.getAnnotation(JacksonInject.class) != null) {
path = new StringBuilder(StringUtils.format(" -- Injected field[%s] not bound!?", fieldName));
break;
}
JsonProperty annotation = theField.getAnnotation(JsonProperty.class);
final boolean noAnnotationValue = annotation == null || Strings.isNullOrEmpty(annotation.value());
final String pathPart = noAnnotationValue ? fieldName : annotation.value();
if (path.length() == 0) {
path.append(pathPart);
} else {
path.append(".").append(pathPart);
}
}
}
} catch (NoSuchFieldException e) {
throw new RuntimeException(e);
}
messages.add(StringUtils.format("%s - %s", path.toString(), violation.getMessage()));
}
throw new ProvisionException(Iterables.transform(messages, new Function<String, Message>() {
@Override
public Message apply(String input) {
return new Message(StringUtils.format("%s%s", propertyBase, input));
}
}));
}
log.debug("Loaded class[%s] from props[%s] as [%s]", clazz, propertyBase, config);
return config;
}
use of org.apache.flink.shaded.jackson2.com.fasterxml.jackson.annotation.JsonProperty in project swagger-core by swagger-api.
the class ModelResolver method resolve.
@Override
public Schema resolve(AnnotatedType annotatedType, ModelConverterContext context, Iterator<ModelConverter> next) {
boolean isPrimitive = false;
Schema model = null;
List<String> requiredProps = new ArrayList<>();
if (annotatedType == null) {
return null;
}
if (this.shouldIgnoreClass(annotatedType.getType())) {
return null;
}
final JavaType type;
if (annotatedType.getType() instanceof JavaType) {
type = (JavaType) annotatedType.getType();
} else {
type = _mapper.constructType(annotatedType.getType());
}
final Annotation resolvedSchemaOrArrayAnnotation = AnnotationsUtils.mergeSchemaAnnotations(annotatedType.getCtxAnnotations(), type);
final io.swagger.v3.oas.annotations.media.Schema resolvedSchemaAnnotation = resolvedSchemaOrArrayAnnotation == null ? null : resolvedSchemaOrArrayAnnotation instanceof io.swagger.v3.oas.annotations.media.ArraySchema ? ((io.swagger.v3.oas.annotations.media.ArraySchema) resolvedSchemaOrArrayAnnotation).schema() : (io.swagger.v3.oas.annotations.media.Schema) resolvedSchemaOrArrayAnnotation;
final io.swagger.v3.oas.annotations.media.ArraySchema resolvedArrayAnnotation = resolvedSchemaOrArrayAnnotation == null ? null : resolvedSchemaOrArrayAnnotation instanceof io.swagger.v3.oas.annotations.media.ArraySchema ? (io.swagger.v3.oas.annotations.media.ArraySchema) resolvedSchemaOrArrayAnnotation : null;
final BeanDescription beanDesc;
{
BeanDescription recurBeanDesc = _mapper.getSerializationConfig().introspect(type);
HashSet<String> visited = new HashSet<>();
JsonSerialize jsonSerialize = recurBeanDesc.getClassAnnotations().get(JsonSerialize.class);
while (jsonSerialize != null && !Void.class.equals(jsonSerialize.as())) {
String asName = jsonSerialize.as().getName();
if (visited.contains(asName))
break;
visited.add(asName);
recurBeanDesc = _mapper.getSerializationConfig().introspect(_mapper.constructType(jsonSerialize.as()));
jsonSerialize = recurBeanDesc.getClassAnnotations().get(JsonSerialize.class);
}
beanDesc = recurBeanDesc;
}
String name = annotatedType.getName();
if (StringUtils.isBlank(name)) {
// allow override of name from annotation
if (!annotatedType.isSkipSchemaName() && resolvedSchemaAnnotation != null && !resolvedSchemaAnnotation.name().isEmpty()) {
name = resolvedSchemaAnnotation.name();
}
if (StringUtils.isBlank(name) && !ReflectionUtils.isSystemType(type)) {
name = _typeName(type, beanDesc);
}
}
name = decorateModelName(annotatedType, name);
// if we have a ref we don't consider anything else
if (resolvedSchemaAnnotation != null && StringUtils.isNotEmpty(resolvedSchemaAnnotation.ref())) {
if (resolvedArrayAnnotation == null) {
return new Schema().$ref(resolvedSchemaAnnotation.ref()).name(name);
} else {
ArraySchema schema = new ArraySchema();
resolveArraySchema(annotatedType, schema, resolvedArrayAnnotation);
return schema.items(new Schema().$ref(resolvedSchemaAnnotation.ref()).name(name));
}
}
if (!annotatedType.isSkipOverride() && resolvedSchemaAnnotation != null && !Void.class.equals(resolvedSchemaAnnotation.implementation())) {
Class<?> cls = resolvedSchemaAnnotation.implementation();
LOGGER.debug("overriding datatype from {} to {}", type, cls.getName());
Annotation[] ctxAnnotation = null;
if (resolvedArrayAnnotation != null && annotatedType.getCtxAnnotations() != null) {
List<Annotation> annList = new ArrayList<>();
for (Annotation a : annotatedType.getCtxAnnotations()) {
if (!(a instanceof ArraySchema)) {
annList.add(a);
}
}
annList.add(resolvedSchemaAnnotation);
ctxAnnotation = annList.toArray(new Annotation[annList.size()]);
} else {
ctxAnnotation = annotatedType.getCtxAnnotations();
}
AnnotatedType aType = new AnnotatedType().type(cls).ctxAnnotations(ctxAnnotation).parent(annotatedType.getParent()).name(annotatedType.getName()).resolveAsRef(annotatedType.isResolveAsRef()).jsonViewAnnotation(annotatedType.getJsonViewAnnotation()).propertyName(annotatedType.getPropertyName()).skipOverride(true);
if (resolvedArrayAnnotation != null) {
ArraySchema schema = new ArraySchema();
resolveArraySchema(annotatedType, schema, resolvedArrayAnnotation);
Schema innerSchema = null;
Schema primitive = PrimitiveType.createProperty(cls);
if (primitive != null) {
innerSchema = primitive;
} else {
innerSchema = context.resolve(aType);
if (innerSchema != null && "object".equals(innerSchema.getType()) && StringUtils.isNotBlank(innerSchema.getName())) {
// create a reference for the items
if (context.getDefinedModels().containsKey(innerSchema.getName())) {
innerSchema = new Schema().$ref(constructRef(innerSchema.getName()));
}
} else if (innerSchema != null && innerSchema.get$ref() != null) {
innerSchema = new Schema().$ref(StringUtils.isNotEmpty(innerSchema.get$ref()) ? innerSchema.get$ref() : innerSchema.getName());
}
}
schema.setItems(innerSchema);
return schema;
} else {
Schema implSchema = context.resolve(aType);
if (implSchema != null && aType.isResolveAsRef() && "object".equals(implSchema.getType()) && StringUtils.isNotBlank(implSchema.getName())) {
// create a reference for the items
if (context.getDefinedModels().containsKey(implSchema.getName())) {
implSchema = new Schema().$ref(constructRef(implSchema.getName()));
}
} else if (implSchema != null && implSchema.get$ref() != null) {
implSchema = new Schema().$ref(StringUtils.isNotEmpty(implSchema.get$ref()) ? implSchema.get$ref() : implSchema.getName());
}
return implSchema;
}
}
if (model == null && !annotatedType.isSkipOverride() && resolvedSchemaAnnotation != null && StringUtils.isNotEmpty(resolvedSchemaAnnotation.type()) && !resolvedSchemaAnnotation.type().equals("object")) {
PrimitiveType primitiveType = PrimitiveType.fromTypeAndFormat(resolvedSchemaAnnotation.type(), resolvedSchemaAnnotation.format());
if (primitiveType == null) {
primitiveType = PrimitiveType.fromType(type);
}
if (primitiveType == null) {
primitiveType = PrimitiveType.fromName(resolvedSchemaAnnotation.type());
}
if (primitiveType != null) {
Schema primitive = primitiveType.createProperty();
model = primitive;
isPrimitive = true;
}
}
if (model == null && type.isEnumType()) {
model = new StringSchema();
_addEnumProps(type.getRawClass(), model);
isPrimitive = true;
}
if (model == null) {
PrimitiveType primitiveType = PrimitiveType.fromType(type);
if (primitiveType != null) {
model = PrimitiveType.fromType(type).createProperty();
isPrimitive = true;
}
}
if (!annotatedType.isSkipJsonIdentity()) {
JsonIdentityInfo jsonIdentityInfo = AnnotationsUtils.getAnnotation(JsonIdentityInfo.class, annotatedType.getCtxAnnotations());
if (jsonIdentityInfo == null) {
jsonIdentityInfo = type.getRawClass().getAnnotation(JsonIdentityInfo.class);
}
if (model == null && jsonIdentityInfo != null) {
JsonIdentityReference jsonIdentityReference = AnnotationsUtils.getAnnotation(JsonIdentityReference.class, annotatedType.getCtxAnnotations());
if (jsonIdentityReference == null) {
jsonIdentityReference = type.getRawClass().getAnnotation(JsonIdentityReference.class);
}
model = new GeneratorWrapper().processJsonIdentity(annotatedType, context, _mapper, jsonIdentityInfo, jsonIdentityReference);
if (model != null) {
return model;
}
}
}
if (model == null && annotatedType.getJsonUnwrappedHandler() != null) {
model = annotatedType.getJsonUnwrappedHandler().apply(annotatedType);
if (model == null) {
return null;
}
}
if ("Object".equals(name)) {
return new Schema();
}
if (isPrimitive) {
if (annotatedType.isSchemaProperty()) {
// model.name(name);
}
XML xml = resolveXml(beanDesc.getClassInfo(), annotatedType.getCtxAnnotations(), resolvedSchemaAnnotation);
if (xml != null) {
model.xml(xml);
}
applyBeanValidatorAnnotations(model, annotatedType.getCtxAnnotations(), null);
resolveSchemaMembers(model, annotatedType);
if (resolvedArrayAnnotation != null) {
ArraySchema schema = new ArraySchema();
resolveArraySchema(annotatedType, schema, resolvedArrayAnnotation);
schema.setItems(model);
return schema;
}
if (type.isEnumType() && shouldResolveEnumAsRef(resolvedSchemaAnnotation)) {
// Store off the ref and add the enum as a top-level model
context.defineModel(name, model, annotatedType, null);
// Return the model as a ref only property
model = new Schema().$ref(Components.COMPONENTS_SCHEMAS_REF + name);
}
return model;
}
/**
* --Preventing parent/child hierarchy creation loops - Comment 1--
* Creating a parent model will result in the creation of child models. Creating a child model will result in
* the creation of a parent model, as per the second If statement following this comment.
*
* By checking whether a model has already been resolved (as implemented below), loops of parents creating
* children and children creating parents can be short-circuited. This works because currently the
* ModelConverterContextImpl will return null for a class that already been processed, but has not yet been
* defined. This logic works in conjunction with the early immediate definition of model in the context
* implemented later in this method (See "Preventing parent/child hierarchy creation loops - Comment 2") to
* prevent such
*/
Schema resolvedModel = context.resolve(annotatedType);
if (resolvedModel != null) {
if (name != null && name.equals(resolvedModel.getName())) {
return resolvedModel;
}
}
Type jsonValueType = findJsonValueType(beanDesc);
if (jsonValueType != null) {
AnnotatedType aType = new AnnotatedType().type(jsonValueType).parent(annotatedType.getParent()).name(annotatedType.getName()).schemaProperty(annotatedType.isSchemaProperty()).resolveAsRef(annotatedType.isResolveAsRef()).jsonViewAnnotation(annotatedType.getJsonViewAnnotation()).propertyName(annotatedType.getPropertyName()).ctxAnnotations(annotatedType.getCtxAnnotations()).skipOverride(true);
return context.resolve(aType);
}
List<Class<?>> composedSchemaReferencedClasses = getComposedSchemaReferencedClasses(type.getRawClass(), annotatedType.getCtxAnnotations(), resolvedSchemaAnnotation);
boolean isComposedSchema = composedSchemaReferencedClasses != null;
if (type.isContainerType()) {
// TODO currently a MapSchema or ArraySchema don't also support composed schema props (oneOf,..)
isComposedSchema = false;
JavaType keyType = type.getKeyType();
JavaType valueType = type.getContentType();
String pName = null;
if (valueType != null) {
BeanDescription valueTypeBeanDesc = _mapper.getSerializationConfig().introspect(valueType);
pName = _typeName(valueType, valueTypeBeanDesc);
}
Annotation[] schemaAnnotations = null;
if (resolvedSchemaAnnotation != null) {
schemaAnnotations = new Annotation[] { resolvedSchemaAnnotation };
}
if (keyType != null && valueType != null) {
if (ReflectionUtils.isSystemType(type) && !annotatedType.isSchemaProperty() && !annotatedType.isResolveAsRef()) {
context.resolve(new AnnotatedType().type(valueType).jsonViewAnnotation(annotatedType.getJsonViewAnnotation()));
return null;
}
Schema addPropertiesSchema = context.resolve(new AnnotatedType().type(valueType).schemaProperty(annotatedType.isSchemaProperty()).ctxAnnotations(schemaAnnotations).skipSchemaName(true).resolveAsRef(annotatedType.isResolveAsRef()).jsonViewAnnotation(annotatedType.getJsonViewAnnotation()).propertyName(annotatedType.getPropertyName()).parent(annotatedType.getParent()));
if (addPropertiesSchema != null) {
if (StringUtils.isNotBlank(addPropertiesSchema.getName())) {
pName = addPropertiesSchema.getName();
}
if ("object".equals(addPropertiesSchema.getType()) && pName != null) {
// create a reference for the items
if (context.getDefinedModels().containsKey(pName)) {
addPropertiesSchema = new Schema().$ref(constructRef(pName));
}
} else if (addPropertiesSchema.get$ref() != null) {
addPropertiesSchema = new Schema().$ref(StringUtils.isNotEmpty(addPropertiesSchema.get$ref()) ? addPropertiesSchema.get$ref() : addPropertiesSchema.getName());
}
}
Schema mapModel = new MapSchema().additionalProperties(addPropertiesSchema);
mapModel.name(name);
model = mapModel;
// return model;
} else if (valueType != null) {
if (ReflectionUtils.isSystemType(type) && !annotatedType.isSchemaProperty() && !annotatedType.isResolveAsRef()) {
context.resolve(new AnnotatedType().type(valueType).jsonViewAnnotation(annotatedType.getJsonViewAnnotation()));
return null;
}
Schema items = context.resolve(new AnnotatedType().type(valueType).schemaProperty(annotatedType.isSchemaProperty()).ctxAnnotations(schemaAnnotations).skipSchemaName(true).resolveAsRef(annotatedType.isResolveAsRef()).propertyName(annotatedType.getPropertyName()).jsonViewAnnotation(annotatedType.getJsonViewAnnotation()).parent(annotatedType.getParent()));
if (items == null) {
return null;
}
if (annotatedType.isSchemaProperty() && annotatedType.getCtxAnnotations() != null && annotatedType.getCtxAnnotations().length > 0) {
if (!"object".equals(items.getType())) {
for (Annotation annotation : annotatedType.getCtxAnnotations()) {
if (annotation instanceof XmlElement) {
XmlElement xmlElement = (XmlElement) annotation;
if (xmlElement != null && xmlElement.name() != null && !"".equals(xmlElement.name()) && !JAXB_DEFAULT.equals(xmlElement.name())) {
XML xml = items.getXml() != null ? items.getXml() : new XML();
xml.setName(xmlElement.name());
items.setXml(xml);
}
}
}
}
}
if (StringUtils.isNotBlank(items.getName())) {
pName = items.getName();
}
if ("object".equals(items.getType()) && pName != null) {
// create a reference for the items
if (context.getDefinedModels().containsKey(pName)) {
items = new Schema().$ref(constructRef(pName));
}
} else if (items.get$ref() != null) {
items = new Schema().$ref(StringUtils.isNotEmpty(items.get$ref()) ? items.get$ref() : items.getName());
}
Schema arrayModel = new ArraySchema().items(items);
if (_isSetType(type.getRawClass())) {
arrayModel.setUniqueItems(true);
}
arrayModel.name(name);
model = arrayModel;
} else {
if (ReflectionUtils.isSystemType(type) && !annotatedType.isSchemaProperty() && !annotatedType.isResolveAsRef()) {
return null;
}
}
} else if (isComposedSchema) {
model = new ComposedSchema().type("object").name(name);
} else {
AnnotatedType aType = OptionalUtils.unwrapOptional(annotatedType);
if (aType != null) {
model = context.resolve(aType);
return model;
} else {
model = new Schema().type("object").name(name);
}
}
if (!type.isContainerType() && StringUtils.isNotBlank(name)) {
// define the model here to support self/cyclic referencing of models
context.defineModel(name, model, annotatedType, null);
}
XML xml = resolveXml(beanDesc.getClassInfo(), annotatedType.getCtxAnnotations(), resolvedSchemaAnnotation);
if (xml != null) {
model.xml(xml);
}
if (!(model instanceof ArraySchema) || (model instanceof ArraySchema && resolvedArrayAnnotation == null)) {
resolveSchemaMembers(model, annotatedType);
}
final XmlAccessorType xmlAccessorTypeAnnotation = beanDesc.getClassAnnotations().get(XmlAccessorType.class);
// see if @JsonIgnoreProperties exist
Set<String> propertiesToIgnore = resolveIgnoredProperties(beanDesc.getClassAnnotations(), annotatedType.getCtxAnnotations());
List<Schema> props = new ArrayList<>();
Map<String, Schema> modelProps = new LinkedHashMap<>();
List<BeanPropertyDefinition> properties = beanDesc.findProperties();
List<String> ignoredProps = getIgnoredProperties(beanDesc);
properties.removeIf(p -> ignoredProps.contains(p.getName()));
for (BeanPropertyDefinition propDef : properties) {
Schema property = null;
String propName = propDef.getName();
Annotation[] annotations = null;
AnnotatedMember member = propDef.getPrimaryMember();
if (member == null) {
final BeanDescription deserBeanDesc = _mapper.getDeserializationConfig().introspect(type);
List<BeanPropertyDefinition> deserProperties = deserBeanDesc.findProperties();
for (BeanPropertyDefinition prop : deserProperties) {
if (StringUtils.isNotBlank(prop.getInternalName()) && prop.getInternalName().equals(propDef.getInternalName())) {
member = prop.getPrimaryMember();
break;
}
}
}
// it's ugly but gets around https://github.com/swagger-api/swagger-core/issues/415
if (propDef.getPrimaryMember() != null) {
final JsonProperty jsonPropertyAnn = propDef.getPrimaryMember().getAnnotation(JsonProperty.class);
if (jsonPropertyAnn == null || !jsonPropertyAnn.value().equals(propName)) {
if (member != null) {
java.lang.reflect.Member innerMember = member.getMember();
if (innerMember != null) {
String altName = innerMember.getName();
if (altName != null) {
final int length = altName.length();
for (String prefix : Arrays.asList("get", "is")) {
final int offset = prefix.length();
if (altName.startsWith(prefix) && length > offset && !Character.isUpperCase(altName.charAt(offset))) {
propName = altName;
break;
}
}
}
}
}
}
}
PropertyMetadata md = propDef.getMetadata();
if (member != null && !ignore(member, xmlAccessorTypeAnnotation, propName, propertiesToIgnore, propDef)) {
List<Annotation> annotationList = new ArrayList<>();
AnnotationMap annotationMap = member.getAllAnnotations();
if (annotationMap != null) {
for (Annotation a : annotationMap.annotations()) {
annotationList.add(a);
}
}
annotations = annotationList.toArray(new Annotation[annotationList.size()]);
if (hiddenByJsonView(annotations, annotatedType)) {
continue;
}
JavaType propType = member.getType();
if (propType != null && "void".equals(propType.getRawClass().getName())) {
if (member instanceof AnnotatedMethod) {
propType = ((AnnotatedMethod) member).getParameterType(0);
}
}
String propSchemaName = null;
io.swagger.v3.oas.annotations.media.Schema ctxSchema = AnnotationsUtils.getSchemaAnnotation(annotations);
if (AnnotationsUtils.hasSchemaAnnotation(ctxSchema)) {
if (!StringUtils.isBlank(ctxSchema.name())) {
propSchemaName = ctxSchema.name();
}
}
if (propSchemaName == null) {
io.swagger.v3.oas.annotations.media.ArraySchema ctxArraySchema = AnnotationsUtils.getArraySchemaAnnotation(annotations);
if (AnnotationsUtils.hasArrayAnnotation(ctxArraySchema)) {
if (AnnotationsUtils.hasSchemaAnnotation(ctxArraySchema.schema())) {
if (!StringUtils.isBlank(ctxArraySchema.schema().name())) {
propSchemaName = ctxArraySchema.schema().name();
}
}
}
}
if (StringUtils.isNotBlank(propSchemaName)) {
propName = propSchemaName;
}
Annotation propSchemaOrArray = AnnotationsUtils.mergeSchemaAnnotations(annotations, propType);
final io.swagger.v3.oas.annotations.media.Schema propResolvedSchemaAnnotation = propSchemaOrArray == null ? null : propSchemaOrArray instanceof io.swagger.v3.oas.annotations.media.ArraySchema ? ((io.swagger.v3.oas.annotations.media.ArraySchema) propSchemaOrArray).schema() : (io.swagger.v3.oas.annotations.media.Schema) propSchemaOrArray;
io.swagger.v3.oas.annotations.media.Schema.AccessMode accessMode = resolveAccessMode(propDef, type, propResolvedSchemaAnnotation);
AnnotatedType aType = new AnnotatedType().type(propType).ctxAnnotations(annotations).parent(model).resolveAsRef(annotatedType.isResolveAsRef()).jsonViewAnnotation(annotatedType.getJsonViewAnnotation()).skipSchemaName(true).schemaProperty(true).propertyName(propName);
final AnnotatedMember propMember = member;
aType.jsonUnwrappedHandler(t -> {
JsonUnwrapped uw = propMember.getAnnotation(JsonUnwrapped.class);
if (uw != null && uw.enabled()) {
t.ctxAnnotations(null).jsonUnwrappedHandler(null).resolveAsRef(false);
handleUnwrapped(props, context.resolve(t), uw.prefix(), uw.suffix(), requiredProps);
return null;
} else {
return new Schema();
// t.jsonUnwrappedHandler(null);
// return context.resolve(t);
}
});
property = clone(context.resolve(aType));
if (property != null) {
Boolean required = md.getRequired();
if (required != null && !Boolean.FALSE.equals(required)) {
addRequiredItem(model, propName);
} else {
if (propDef.isRequired()) {
addRequiredItem(model, propName);
}
}
if (property.get$ref() == null) {
if (accessMode != null) {
switch(accessMode) {
case AUTO:
break;
case READ_ONLY:
property.readOnly(true);
break;
case READ_WRITE:
break;
case WRITE_ONLY:
property.writeOnly(true);
break;
default:
}
}
}
final BeanDescription propBeanDesc = _mapper.getSerializationConfig().introspect(propType);
if (property != null && !propType.isContainerType()) {
if ("object".equals(property.getType())) {
// create a reference for the property
String pName = _typeName(propType, propBeanDesc);
if (StringUtils.isNotBlank(property.getName())) {
pName = property.getName();
}
if (context.getDefinedModels().containsKey(pName)) {
property = new Schema().$ref(constructRef(pName));
}
} else if (property.get$ref() != null) {
property = new Schema().$ref(StringUtils.isNotEmpty(property.get$ref()) ? property.get$ref() : property.getName());
}
}
property.setName(propName);
JAXBAnnotationsHelper.apply(propBeanDesc.getClassInfo(), annotations, property);
applyBeanValidatorAnnotations(property, annotations, model);
props.add(property);
}
}
}
for (Schema prop : props) {
modelProps.put(prop.getName(), prop);
}
if (modelProps.size() > 0) {
model.setProperties(modelProps);
for (String propName : requiredProps) {
addRequiredItem(model, propName);
}
}
/**
* --Preventing parent/child hierarchy creation loops - Comment 2--
* Creating a parent model will result in the creation of child models, as per the first If statement following
* this comment. Creating a child model will result in the creation of a parent model, as per the second If
* statement following this comment.
*
* The current model must be defined in the context immediately. This done to help prevent repeated
* loops where parents create children and children create parents when a hierarchy is present. This logic
* works in conjunction with the "early checking" performed earlier in this method
* (See "Preventing parent/child hierarchy creation loops - Comment 1"), to prevent repeated creation loops.
*
* As an aside, defining the current model in the context immediately also ensures that child models are
* available for modification by resolveSubtypes, when their parents are created.
*/
if (!type.isContainerType() && StringUtils.isNotBlank(name)) {
context.defineModel(name, model, annotatedType, null);
}
/**
* This must be done after model.setProperties so that the model's set
* of properties is available to filter from any subtypes
*/
if (!resolveSubtypes(model, beanDesc, context)) {
model.setDiscriminator(null);
}
Discriminator discriminator = resolveDiscriminator(type, context);
if (discriminator != null) {
model.setDiscriminator(discriminator);
}
if (resolvedSchemaAnnotation != null) {
String ref = resolvedSchemaAnnotation.ref();
// consider ref as is
if (!StringUtils.isBlank(ref)) {
model.$ref(ref);
}
Class<?> not = resolvedSchemaAnnotation.not();
if (!Void.class.equals(not)) {
model.not((new Schema().$ref(context.resolve(new AnnotatedType().type(not).jsonViewAnnotation(annotatedType.getJsonViewAnnotation())).getName())));
}
if (resolvedSchemaAnnotation.requiredProperties() != null && resolvedSchemaAnnotation.requiredProperties().length > 0 && StringUtils.isNotBlank(resolvedSchemaAnnotation.requiredProperties()[0])) {
for (String prop : resolvedSchemaAnnotation.requiredProperties()) {
addRequiredItem(model, prop);
}
}
}
Map<String, Schema> patternProperties = resolvePatternProperties(type, annotatedType.getCtxAnnotations(), context);
if (model != null && patternProperties != null && !patternProperties.isEmpty()) {
if (model.getPatternProperties() == null) {
model.patternProperties(patternProperties);
} else {
model.getPatternProperties().putAll(patternProperties);
}
}
Map<String, Schema> schemaProperties = resolveSchemaProperties(type, annotatedType.getCtxAnnotations(), context);
if (model != null && schemaProperties != null && !schemaProperties.isEmpty()) {
if (model.getProperties() == null) {
model.properties(schemaProperties);
} else {
model.getProperties().putAll(schemaProperties);
}
}
if (isComposedSchema) {
ComposedSchema composedSchema = (ComposedSchema) model;
Class<?>[] allOf = resolvedSchemaAnnotation.allOf();
Class<?>[] anyOf = resolvedSchemaAnnotation.anyOf();
Class<?>[] oneOf = resolvedSchemaAnnotation.oneOf();
List<Class<?>> allOfFiltered = Stream.of(allOf).distinct().filter(c -> !this.shouldIgnoreClass(c)).filter(c -> !(c.equals(Void.class))).collect(Collectors.toList());
allOfFiltered.forEach(c -> {
Schema allOfRef = context.resolve(new AnnotatedType().type(c).jsonViewAnnotation(annotatedType.getJsonViewAnnotation()));
Schema refSchema = new Schema().$ref(allOfRef.getName());
// allOf could have already being added during subtype resolving
if (composedSchema.getAllOf() == null || !composedSchema.getAllOf().contains(refSchema)) {
composedSchema.addAllOfItem(refSchema);
}
// remove shared properties defined in the parent
if (isSubtype(beanDesc.getClassInfo(), c)) {
removeParentProperties(composedSchema, allOfRef);
}
});
List<Class<?>> anyOfFiltered = Stream.of(anyOf).distinct().filter(c -> !this.shouldIgnoreClass(c)).filter(c -> !(c.equals(Void.class))).collect(Collectors.toList());
anyOfFiltered.forEach(c -> {
Schema anyOfRef = context.resolve(new AnnotatedType().type(c).jsonViewAnnotation(annotatedType.getJsonViewAnnotation()));
composedSchema.addAnyOfItem(new Schema().$ref(anyOfRef.getName()));
// remove shared properties defined in the parent
if (isSubtype(beanDesc.getClassInfo(), c)) {
removeParentProperties(composedSchema, anyOfRef);
}
});
List<Class<?>> oneOfFiltered = Stream.of(oneOf).distinct().filter(c -> !this.shouldIgnoreClass(c)).filter(c -> !(c.equals(Void.class))).collect(Collectors.toList());
oneOfFiltered.forEach(c -> {
Schema oneOfRef = context.resolve(new AnnotatedType().type(c).jsonViewAnnotation(annotatedType.getJsonViewAnnotation()));
if (oneOfRef != null) {
if (StringUtils.isBlank(oneOfRef.getName())) {
composedSchema.addOneOfItem(oneOfRef);
} else {
composedSchema.addOneOfItem(new Schema().$ref(oneOfRef.getName()));
}
// remove shared properties defined in the parent
if (isSubtype(beanDesc.getClassInfo(), c)) {
removeParentProperties(composedSchema, oneOfRef);
}
}
});
if (!composedModelPropertiesAsSibling) {
if (composedSchema.getAllOf() != null && !composedSchema.getAllOf().isEmpty()) {
if (composedSchema.getProperties() != null && !composedSchema.getProperties().isEmpty()) {
ObjectSchema propSchema = new ObjectSchema();
propSchema.properties(composedSchema.getProperties());
composedSchema.setProperties(null);
composedSchema.addAllOfItem(propSchema);
}
}
}
}
if (!type.isContainerType() && StringUtils.isNotBlank(name)) {
// define the model here to support self/cyclic referencing of models
context.defineModel(name, model, annotatedType, null);
}
if (model != null && annotatedType.isResolveAsRef() && (isComposedSchema || "object".equals(model.getType())) && StringUtils.isNotBlank(model.getName())) {
if (context.getDefinedModels().containsKey(model.getName())) {
model = new Schema().$ref(constructRef(model.getName()));
}
} else if (model != null && model.get$ref() != null) {
model = new Schema().$ref(StringUtils.isNotEmpty(model.get$ref()) ? model.get$ref() : model.getName());
}
if (model != null && resolvedArrayAnnotation != null) {
if (!"array".equals(model.getType())) {
ArraySchema schema = new ArraySchema();
schema.setItems(model);
resolveArraySchema(annotatedType, schema, resolvedArrayAnnotation);
return schema;
} else {
if (model instanceof ArraySchema) {
resolveArraySchema(annotatedType, (ArraySchema) model, resolvedArrayAnnotation);
}
}
}
resolveDiscriminatorProperty(type, context, model);
model = resolveWrapping(type, context, model);
return model;
}
use of org.apache.flink.shaded.jackson2.com.fasterxml.jackson.annotation.JsonProperty in project UVMS-ActivityModule-APP by UnionVMS.
the class ActivityDetailsDto method getCharacteristics.
@JsonProperty("characteristics")
@JsonView({ CommonView.class })
public Map<String, Set<Object>> getCharacteristics() {
Map<String, Set<Object>> characMap = null;
if (fluxCharacteristics != null) {
characMap = Maps.newHashMap();
for (FluxCharacteristicsDto fluxCharacteristicsDto : fluxCharacteristics) {
Double calculatedValueMeasure = fluxCharacteristicsDto.getCalculatedValueMeasure();
add("calculatedValueMeasure", calculatedValueMeasure, characMap);
Double calculatedValueQuantity = fluxCharacteristicsDto.getCalculatedValueQuantity();
add("calculatedValueQuantity", calculatedValueQuantity, characMap);
String description = fluxCharacteristicsDto.getDescription();
add("description", description, characMap);
String descriptionLanguageId = fluxCharacteristicsDto.getDescriptionLanguageId();
add("descriptionLanguageId", descriptionLanguageId, characMap);
String typeCode = fluxCharacteristicsDto.getTypeCode();
add("typeCode", typeCode, characMap);
String typeCodeListId = fluxCharacteristicsDto.getTypeCodeListId();
add("typeCodeListId", typeCodeListId, characMap);
Date valueDateTime = fluxCharacteristicsDto.getValueDateTime();
add("valueDateTime", valueDateTime, characMap);
String valueIndicator = fluxCharacteristicsDto.getValueIndicator();
add("valueIndicator", valueIndicator, characMap);
Double valueMeasure = fluxCharacteristicsDto.getValueMeasure();
add("valueMeasure", valueMeasure, characMap);
String valueMeasureUnitCode = fluxCharacteristicsDto.getValueMeasureUnitCode();
add("valueMeasureUnitCode", valueMeasureUnitCode, characMap);
Double valueQuantity = fluxCharacteristicsDto.getValueQuantity();
add("valueQuantity", valueQuantity, characMap);
String valueQuantityCode = fluxCharacteristicsDto.getValueQuantityCode();
add("valueQuantityCode", valueQuantityCode, characMap);
String valueLanguageId = fluxCharacteristicsDto.getValueLanguageId();
add("valueLanguageId", valueLanguageId, characMap);
String valueCode = fluxCharacteristicsDto.getValueCode();
add("valueCode", valueCode, characMap);
}
}
return characMap;
}
use of org.apache.flink.shaded.jackson2.com.fasterxml.jackson.annotation.JsonProperty in project autorest-clientruntime-for-java by Azure.
the class AdditionalPropertiesDeserializer method deserialize.
@SuppressWarnings("unchecked")
@Override
public Object deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
ObjectNode root = mapper.readTree(jp);
ObjectNode copy = root.deepCopy();
// compare top level fields and keep only missing fields
final Class<?> tClass = this.defaultDeserializer.handledType();
for (Class<?> c : TypeToken.of(tClass).getTypes().classes().rawTypes()) {
Field[] fields = c.getDeclaredFields();
for (Field field : fields) {
JsonProperty property = field.getAnnotation(JsonProperty.class);
if (property != null) {
String key = property.value().split("((?<!\\\\))\\.")[0];
if (!key.isEmpty()) {
if (copy.has(key)) {
copy.remove(key);
}
}
}
}
}
// put into additional properties
root.put("additionalProperties", copy);
JsonParser parser = new JsonFactory().createParser(root.toString());
parser.nextToken();
return defaultDeserializer.deserialize(parser, ctxt);
}
Aggregations