1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
package xyz.driver.core
import java.lang.annotation.Annotation
import java.lang.reflect.Type
import java.util
import com.fasterxml.jackson.databind.{BeanDescription, ObjectMapper}
import com.fasterxml.jackson.databind.`type`.ReferenceType
import io.swagger.converter._
import io.swagger.jackson.AbstractModelConverter
import io.swagger.models.{Model, ModelImpl}
import io.swagger.models.properties._
import io.swagger.util.{Json, PrimitiveType}
import spray.json._
object swagger {
def configureCustomSwaggerModels(
customPropertiesExamples: Map[Class[_], Property],
customObjectsExamples: Map[Class[_], JsValue]) = {
ModelConverters
.getInstance()
.addConverter(new CustomSwaggerJsonConverter(Json.mapper(), customPropertiesExamples, customObjectsExamples))
}
object CustomSwaggerJsonConverter {
def stringProperty(pattern: Option[String] = None, example: Option[String] = None): Property = {
make(new StringProperty()) { sp =>
sp.required(true)
example.foreach(sp.example)
pattern.foreach(sp.pattern)
}
}
def enumProperty[V](values: V*): Property = {
make(new StringProperty()) { sp =>
for (v <- values) sp._enum(v.toString)
sp.setRequired(true)
}
}
def numericProperty(example: Option[AnyRef] = None): Property = {
make(PrimitiveType.DECIMAL.createProperty()) { dp =>
dp.setRequired(true)
example.foreach(dp.setExample)
}
}
def booleanProperty(): Property = {
make(new BooleanProperty()) { bp =>
bp.setRequired(true)
}
}
}
@SuppressWarnings(Array("org.wartremover.warts.Null"))
class CustomSwaggerJsonConverter(
mapper: ObjectMapper,
customProperties: Map[Class[_], Property],
customObjects: Map[Class[_], JsValue])
extends AbstractModelConverter(mapper) {
import CustomSwaggerJsonConverter._
override def resolveProperty(
`type`: Type,
context: ModelConverterContext,
annotations: Array[Annotation],
chain: util.Iterator[ModelConverter]): Property = {
val javaType = Json.mapper().constructType(`type`)
Option(javaType.getRawClass)
.flatMap { cls =>
customProperties.get(cls)
}
.orElse {
`type` match {
case rt: ReferenceType if isOption(javaType.getRawClass) && chain.hasNext =>
val nextType = rt.getContentType
val nextResolved = Option(resolveProperty(nextType, context, annotations, chain)).getOrElse(
chain.next().resolveProperty(nextType, context, annotations, chain))
nextResolved.setRequired(false)
Option(nextResolved)
case t if chain.hasNext =>
val nextResolved = chain.next().resolveProperty(t, context, annotations, chain)
nextResolved.setRequired(true)
Option(nextResolved)
case _ =>
Option.empty[Property]
}
}
.orNull
}
@SuppressWarnings(Array("org.wartremover.warts.Null"))
override def resolve(`type`: Type, context: ModelConverterContext, chain: util.Iterator[ModelConverter]): Model = {
val javaType = Json.mapper().constructType(`type`)
(getEnumerationInstance(javaType.getRawClass) match {
case Some(_) => Option.empty[Model] // ignore scala enums
case None =>
val customObjectModel = customObjects.get(javaType.getRawClass).map { objectExampleJson =>
val properties = objectExampleJson.asJsObject.fields.mapValues(parseJsonValueToSwaggerProperty).flatMap {
case (key, value) => value.map(v => key -> v)
}
val beanDesc = _mapper.getSerializationConfig.introspect[BeanDescription](javaType)
val name = _typeName(javaType, beanDesc)
make(new ModelImpl()) { model =>
model.name(name)
properties.foreach { case (field, property) => model.addProperty(field, property) }
}
}
customObjectModel.orElse {
if (chain.hasNext) {
val next = chain.next()
Option(next.resolve(`type`, context, chain))
} else {
Option.empty[Model]
}
}
}).orNull
}
private def parseJsonValueToSwaggerProperty(jsValue: JsValue): Option[Property] = {
import scala.collection.JavaConverters._
jsValue match {
case JsArray(elements) =>
elements.headOption.flatMap(parseJsonValueToSwaggerProperty).map { itemProperty =>
new ArrayProperty(itemProperty)
}
case JsObject(subFields) =>
val subProperties = subFields.mapValues(parseJsonValueToSwaggerProperty).flatMap {
case (key, value) => value.map(v => key -> v)
}
Option(new ObjectProperty(subProperties.asJava))
case JsBoolean(_) => Option(booleanProperty())
case JsNumber(value) => Option(numericProperty(example = Option(value)))
case JsString(value) => Option(stringProperty(example = Option(value)))
case _ => Option.empty[Property]
}
}
private def getEnumerationInstance(cls: Class[_]): Option[Enumeration] = {
if (cls.getFields.map(_.getName).contains("MODULE$")) {
val javaUniverse = scala.reflect.runtime.universe
val m = javaUniverse.runtimeMirror(Thread.currentThread().getContextClassLoader)
val moduleMirror = m.reflectModule(m.staticModule(cls.getName))
moduleMirror.instance match {
case enumInstance: Enumeration => Some(enumInstance)
case _ => None
}
} else {
None
}
}
private def isOption(cls: Class[_]): Boolean = cls.equals(classOf[scala.Option[_]])
}
}
|
