blob: 51679c3def088204d7a1d78db2d3791c94bd0861 (
plain) (
blame)
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
|
package xyz.driver.core
import akka.http.scaladsl.model.Uri.Path
import akka.http.scaladsl.server.PathMatcher.Matched
import akka.http.scaladsl.server.{PathMatcher, _}
import akka.http.scaladsl.unmarshalling.Unmarshaller
import xyz.driver.core.revision.Revision
import xyz.driver.core.time.Time
import spray.json.{DeserializationException, JsNumber, _}
import xyz.driver.core.time.Time
import scala.reflect.runtime.universe._
object json {
def IdInPath[T]: PathMatcher1[Id[T]] =
PathMatcher("""[+-]?\d*""".r) flatMap { string =>
try Some(Id[T](string.toLong))
catch { case _: IllegalArgumentException => None }
}
implicit def idFormat[T] = new RootJsonFormat[Id[T]] {
def write(id: Id[T]) = JsNumber(id)
def read(value: JsValue) = value match {
case JsNumber(id) => Id[T](id.toLong)
case _ => throw new DeserializationException("Id expects number")
}
}
def NameInPath[T]: PathMatcher1[Name[T]] = new PathMatcher1[Name[T]] {
def apply(path: Path) = Matched(Path.Empty, Tuple1(Name[T](path.toString)))
}
implicit def nameFormat[T] = new RootJsonFormat[Name[T]] {
def write(name: Name[T]) = JsString(name)
def read(value: JsValue): Name[T] = value match {
case JsString(name) => Name[T](name)
case _ => throw new DeserializationException("Name expects string")
}
}
def TimeInPath: PathMatcher1[Time] =
PathMatcher("""[+-]?\d*""".r) flatMap { string =>
try Some(Time(string.toLong))
catch { case _: IllegalArgumentException => None }
}
implicit val timeFormat = new RootJsonFormat[Time] {
def write(time: Time) = JsObject("timestamp" -> JsNumber(time.millis))
def read(value: JsValue): Time = value match {
case JsObject(fields) =>
fields
.get("timestamp")
.flatMap {
case JsNumber(millis) => Some(Time(millis.toLong))
case _ => None
}
.getOrElse(throw new DeserializationException("Time expects number"))
case _ => throw new DeserializationException("Time expects number")
}
}
def RevisionInPath[T]: PathMatcher1[Revision[T]] =
PathMatcher("""[\da-fA-F]{8}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{12}""".r) flatMap { string =>
Some(Revision[T](string))
}
implicit def revisionFromStringUnmarshaller[T]: Unmarshaller[String, Revision[T]] =
Unmarshaller.strict[String, Revision[T]](Revision[T](_))
implicit def revisionFormat[T] = new RootJsonFormat[Revision[T]] {
def write(revision: Revision[T]) = JsString(revision.id.toString)
def read(value: JsValue): Revision[T] = value match {
case JsString(revision) => Revision[T](revision)
case _ => throw new DeserializationException("Revision expects uuid string")
}
}
class EnumJsonFormat[T](mapping: (String, T)*) extends JsonFormat[T] {
private val map = mapping.toMap
override def write(value: T): JsValue = {
map.find(_._2 == value).map(_._1) match {
case Some(name) => JsString(name)
case _ => serializationError(s"Value $value is not found in the mapping $map")
}
}
override def read(json: JsValue): T = json match {
case JsString(name) =>
map.getOrElse(name, throw new DeserializationException(s"Value $name is not found in the mapping $map"))
case _ => deserializationError("Expected string as enumeration value, but got " + json)
}
}
class ValueClassFormat[T: TypeTag](writeValue: T => BigDecimal, create: BigDecimal => T) extends JsonFormat[T] {
def write(valueClass: T) = JsNumber(writeValue(valueClass))
def read(json: JsValue): T = json match {
case JsNumber(value) => create(value)
case _ => deserializationError(s"Expected number as ${typeOf[T].getClass.getName}, but got " + json)
}
}
}
|
