1 /*
2  *  Make.org Core API
3  *  Copyright (C) 2018 Make.org
4  *
5  * This program is free software: you can redistribute it and/or modify
6  *  it under the terms of the GNU Affero General Public License as
7  *  published by the Free Software Foundation, either version 3 of the
8  *  License, or (at your option) any later version.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU Affero General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Affero General Public License
16  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
17  *
18  */
19 
20 package org.make.core
21 
22 import java.time.{LocalDate, ZonedDateTime}
23 import java.util.UUID
24 
25 import cats.data.NonEmptyList
26 import com.sksamuel.elastic4s.requests.searches.sort.SortOrder
27 import enumeratum.values.{StringEnum, StringEnumEntry}
28 import spray.json._
29 
30 @SuppressWarnings(Array("org.wartremover.warts.Throw"))
31 trait SprayJsonFormatters {
32 
33   implicit val localDateFormatter: JsonFormat[LocalDate] = new JsonFormat[LocalDate] {
34     override def read(json: JsValue): LocalDate = json match {
35       case JsString(s) => LocalDate.parse(s)
36       case other       => throw new IllegalArgumentException(s"Unable to convert $other")
37     }
38 
39     override def write(obj: LocalDate): JsValue = {
40       JsString(obj.toString)
41     }
42   }
43 
44   implicit val zonedDateTimeFormatter: JsonFormat[ZonedDateTime] = new JsonFormat[ZonedDateTime] {
45     override def read(json: JsValue): ZonedDateTime = json match {
46       case JsString(s) => ZonedDateTime.parse(s)
47       case other       => throw new IllegalArgumentException(s"Unable to convert $other")
48     }
49 
50     override def write(obj: ZonedDateTime): JsValue = {
51       JsString(obj.toString)
52     }
53   }
54 
55   implicit val uuidFormatter: JsonFormat[UUID] = new JsonFormat[UUID] {
56     override def read(json: JsValue): UUID = json match {
57       case JsString(s) => UUID.fromString(s)
58       case other       => throw new IllegalArgumentException(s"Unable to convert $other")
59     }
60 
61     override def write(obj: UUID): JsValue = {
62       JsString(obj.toString)
63     }
64   }
65 
66   implicit val sortOrderFormatted: JsonFormat[SortOrder] = new JsonFormat[SortOrder] {
67     override def read(json: JsValue): SortOrder = json match {
68       case JsString(asc) if asc.toLowerCase == "asc"    => SortOrder.Asc
69       case JsString(desc) if desc.toLowerCase == "desc" => SortOrder.Desc
70       case other                                        => throw new IllegalArgumentException(s"Unable to convert $other")
71     }
72 
73     override def write(obj: SortOrder): JsValue = {
74       obj match {
75         case SortOrder.Asc  => JsString("asc")
76         case SortOrder.Desc => JsString("desc")
77       }
78     }
79   }
80 
81   implicit def stringEnumFormatter[A <: StringEnumEntry](implicit stringEnum: StringEnum[A]): JsonFormat[A] =
82     new JsonFormat[A] {
83       override def read(json: JsValue): A = json match {
84         case JsString(s) =>
85           stringEnum.withValueOpt(s).getOrElse(throw new IllegalArgumentException(s"Unable to convert $s"))
86         case other => throw new IllegalArgumentException(s"Unable to convert $other")
87       }
88 
89       override def write(a: A): JsValue = JsString(a.value)
90     }
91 
92 }
93 
94 object SprayJsonFormatters extends SprayJsonFormatters {
95 
96   def forStringValue[T <: StringValue](f: String => T): JsonFormat[T] = new JsonFormat[T] {
97     @SuppressWarnings(Array("org.wartremover.warts.Throw"))
98     override def read(json: JsValue): T = json match {
99       case JsString(s) => f(s)
100       case other       => throw new IllegalArgumentException(s"Unable to convert $other")
101     }
102 
103     override def write(obj: T): JsValue = {
104       JsString(obj.value)
105     }
106   }
107 
108   implicit def nonEmptyListFormat[T](implicit f: JsonFormat[T]): JsonFormat[NonEmptyList[T]] =
109     new JsonFormat[NonEmptyList[T]] {
110 
111       @SuppressWarnings(Array("org.wartremover.warts.Throw"))
112       override def read(json: JsValue): NonEmptyList[T] =
113         json match {
114           case JsArray(vec) =>
115             NonEmptyList.fromFoldable(vec) match {
116               case None      => throw new IllegalArgumentException(s"Array was empty")
117               case Some(nel) => nel.map(_.convertTo[T])
118             }
119           case other => throw new IllegalArgumentException(s"Unable to decode $other")
120         }
121 
122       override def write(obj: NonEmptyList[T]): JsValue =
123         JsArray(obj.map(f.write).toList.toVector)
124     }
125 
126   object syntax {
127 
128     implicit class JsFieldSyntax(val key: String) extends AnyVal {
129       def :=[A: JsonWriter](a: A): JsField = key -> a.toJson
130     }
131 
132     implicit class JsonReaderSyntax(val json: JsValue) extends AnyVal {
133       def as[A](implicit reader: JsonReader[A]): A = reader.read(json)
134     }
135 
136   }
137 
138 }