fix #3998 model schema enum values of jackson fields and private methods

Author: Jason Voss

modules/swagger-core/src/main/java/io/swagger/v3/core/jackson/ModelResolver.java

@@ -77,6 +77,7 @@
 import javax.xml.bind.annotation.XmlSchema;
 import java.io.IOException;
 import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
@@ -955,20 +956,33 @@ protected boolean _isOptionalType(JavaType propType) {
                 .contains(propType.getRawClass().getCanonicalName());
     }
 
+    /**
+     * Adds each enum property value to the model schema
+     *
+     * @param propClass the enum class for which to add properties
+     * @param property the schema to add properties to
+     */
     protected void _addEnumProps(Class<?> propClass, Schema property) {
         final boolean useIndex = _mapper.isEnabled(SerializationFeature.WRITE_ENUMS_USING_INDEX);
         final boolean useToString = _mapper.isEnabled(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);
 
-
-        Optional<Method> jsonValueMethod = Arrays.stream(propClass.getMethods())
+        Optional<Method> jsonValueMethod = Arrays.stream(propClass.getDeclaredMethods())
                 .filter(m -> m.isAnnotationPresent(JsonValue.class))
                 .filter(m -> m.getAnnotation(JsonValue.class).value())
                 .findFirst();
 
+        Optional<Field> jsonValueField = Arrays.stream(propClass.getDeclaredFields())
+                .filter(f -> f.isAnnotationPresent(JsonValue.class))
+                .filter(f -> f.getAnnotation(JsonValue.class).value())
+                .findFirst();
+
+        jsonValueMethod.ifPresent(m -> m.setAccessible(true));
+        jsonValueField.ifPresent(m -> m.setAccessible(true));
         @SuppressWarnings("unchecked")
         Class<Enum<?>> enumClass = (Class<Enum<?>>) propClass;
 
         Enum<?>[] enumConstants = enumClass.getEnumConstants();
+
         if (enumConstants != null) {
             String[] enumValues = _intr.findEnumValues(propClass, enumConstants,
                 new String[enumConstants.length]);
@@ -977,11 +991,13 @@ protected void _addEnumProps(Class<?> propClass, Schema property) {
                 String n;
 
                 String enumValue = enumValues[en.ordinal()];
-                String s = jsonValueMethod.flatMap(m -> ReflectionUtils.safeInvoke(m, en))
-                    .map(Object::toString).orElse(null);
+                String methodValue = jsonValueMethod.flatMap(m -> ReflectionUtils.safeInvoke(m, en)).map(Object::toString).orElse(null);
+                String fieldValue = jsonValueField.flatMap(f -> ReflectionUtils.safeGet(f, en)).map(Object::toString).orElse(null);
 
-                if (s != null) {
-                    n = s;
+                if (methodValue != null) {
+                    n = methodValue;
+                } else if (fieldValue != null) {
+                    n = fieldValue;
                 } else if (enumValue != null) {
                     n = enumValue;
                 } else if (useIndex) {

modules/swagger-core/src/main/java/io/swagger/v3/core/util/ReflectionUtils.java

@@ -435,12 +435,35 @@ public static boolean isSystemType(JavaType type) {
         return type.isArrayType();
     }
 
+    /**
+     * A utility method to get an optional containing result from method or empty optional if unable to access
+     *
+     * @param method from reflect, a method of a class or interface
+     * @param obj the class object in which the method exists
+     * @param args varags of the parameters passed to the method
+     * @return the result of the method, or empty conditional
+     */
     public static Optional<Object> safeInvoke(Method method, Object obj, Object... args) {
         try {
             return Optional.ofNullable(method.invoke(obj, args));
         } catch (IllegalAccessException | InvocationTargetException e) {
             return Optional.empty();
         }
+    }
+
+    /**
+     * A utility method to get an optional containing value of field or empty optional if unable to access
+     *
+     * @param field from reflect, a field of a class or interface
+     * @param obj the class object in which the field exists
+     * @return optional containing the value of the field on the specified object, or empty optional
+     */
+    public static Optional<Object> safeGet(Field field, Object obj) {
+        try {
+            return Optional.ofNullable(field.get(obj));
+        } catch (IllegalAccessException e) {
+            return Optional.empty();
+        }
 
     }
 }

modules/swagger-core/src/test/java/io/swagger/v3/core/converting/EnumPropertyTest.java

@@ -219,5 +219,20 @@ public void testExtractJacksonEnumFields() {
         assertTrue(thirdEnumProperty instanceof StringSchema);
         final StringSchema thirdStringProperty = (StringSchema) thirdEnumProperty;
         assertEquals(thirdStringProperty.getEnum(), Arrays.asList("2", "4", "6"));
+
+        final Schema fourthEnumProperty = (Schema) model.getProperties().get("fourthEnumValue");
+        assertTrue(fourthEnumProperty instanceof StringSchema);
+        final StringSchema fourthStringProperty = (StringSchema) fourthEnumProperty;
+        assertEquals(fourthEnumProperty.getEnum(), Arrays.asList("one", "two", "three"));
+
+        final Schema fifthEnumProperty = (Schema) model.getProperties().get("fifthEnumValue");
+        assertTrue(fifthEnumProperty instanceof StringSchema);
+        final StringSchema fifthStringProperty = (StringSchema) fifthEnumProperty;
+        assertEquals(fifthEnumProperty.getEnum(), Arrays.asList("2", "4", "6"));
+
+        final Schema sixthEnumProperty = (Schema) model.getProperties().get("sixthEnumValue");
+        assertTrue(sixthEnumProperty instanceof StringSchema);
+        final StringSchema sixthStringProperty = (StringSchema) sixthEnumProperty;
+        assertEquals(sixthEnumProperty.getEnum(), Arrays.asList("one", "two", "three"));
     }
 }

modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/JacksonNumberValueEnum.java

@@ -2,6 +2,9 @@
 
 import com.fasterxml.jackson.annotation.JsonValue;
 
+/**
+ * Enum holds values different from names.  Schema model will derive Integer value from jackson annotation JsonValue on public method.
+ */
 public enum JacksonNumberValueEnum {
     FIRST(2),
     SECOND(4),

modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/JacksonNumberValueFieldEnum.java

@@ -0,0 +1,19 @@
+package io.swagger.v3.core.oas.models;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+
+/**
+ * Enum holds values different from names. Schema model will derive Integer value from jackson annotation JsonValue on private field.
+ */
+public enum JacksonNumberValueFieldEnum {
+    FIRST(2),
+    SECOND(4),
+    THIRD(6);
+
+    @JsonValue
+    private final int value;
+
+    JacksonNumberValueFieldEnum(int value) {
+        this.value = value;
+    }
+}

modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/JacksonValueEnum.java

@@ -2,6 +2,9 @@
 
 import com.fasterxml.jackson.annotation.JsonValue;
 
+/**
+ * Enum holds values different from names. Schema model will derive String value from jackson annotation JsonValue on public method.
+ */
 public enum JacksonValueEnum {
     FIRST("one"),
     SECOND("two"),

modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/JacksonValueFieldEnum.java

@@ -0,0 +1,19 @@
+package io.swagger.v3.core.oas.models;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+
+/**
+ * Enum holds values different from names.  Schema model will derive String value from jackson annotation JsonValue on private field.
+ */
+public enum JacksonValueFieldEnum {
+    FIRST("one"),
+    SECOND("two"),
+    THIRD("three");
+
+    @JsonValue
+    private final String value;
+
+    JacksonValueFieldEnum(String value) {
+        this.value = value;
+    }
+}

modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/JacksonValuePrivateEnum.java

@@ -0,0 +1,23 @@
+package io.swagger.v3.core.oas.models;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+
+/**
+ * Enum holds values different from names.  Schema model will derive String value from jackson annotation JsonValue on private method.
+ */
+public enum JacksonValuePrivateEnum {
+    FIRST("one"),
+    SECOND("two"),
+    THIRD("three");
+
+    private final String value;
+
+    JacksonValuePrivateEnum(String value) {
+        this.value = value;
+    }
+
+    @JsonValue
+    private String getValue() {
+        return value;
+    }
+}

modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/ModelWithJacksonEnumField.java

@@ -1,7 +1,13 @@
 package io.swagger.v3.core.oas.models;
 
+/**
+ *  Class of different enums for testing schema model
+ */
 public class ModelWithJacksonEnumField {
     public JacksonPropertyEnum firstEnumValue;
     public JacksonValueEnum secondEnumValue;
     public JacksonNumberValueEnum thirdEnumValue;
+    public JacksonValueFieldEnum fourthEnumValue;
+    public JacksonNumberValueFieldEnum fifthEnumValue;
+    public JacksonValuePrivateEnum sixthEnumValue;
 }