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.net.URI
23 import java.time.{LocalDate, ZonedDateTime}
24 import io.circe._
25 import io.circe.generic.extras.Configuration
26 
27 import java.time.format.DateTimeFormatter
28 import scala.util.{Failure, Success, Try}
29 
30 trait CirceFormatters {
31 
32   implicit val circeConfig: Configuration = Configuration.default
33 
34   implicit lazy val zonedDateTimeEncoder: Encoder[ZonedDateTime] =
35     (a: ZonedDateTime) => Json.fromString(DateFormatters.default.format(a))
36   implicit lazy val zonedDateTimeDecoder: Decoder[ZonedDateTime] =
37     Decoder.decodeString.emap { date =>
38       Try(ZonedDateTime.from(DateFormatters.default.parse(date)))
39         .orElse(Try(ZonedDateTime.parse(date, DateTimeFormatter.ISO_ZONED_DATE_TIME)).map(_.withFixedOffsetZone())) match {
40         case Success(parsed) => Right(parsed)
41         case Failure(_)      => Left(s"$date is not a valid date, it should match yyyy-MM-ddThh:mm:ss.SSSZ")
42       }
43     }
44 
45   implicit lazy val localDateEncoder: Encoder[LocalDate] = (a: LocalDate) => Json.fromString(a.toString)
46   implicit lazy val localDateDecoder: Decoder[LocalDate] =
47     Decoder.decodeString.emap { date =>
48       Try(LocalDate.parse(date)) match {
49         case Success(parsed) => Right(parsed)
50         case Failure(_)      => Left(s"$date is not a valid date, it should match yyyy-MM-dd")
51       }
52     }
53 
54   implicit def h[A, B](implicit a: Decoder[A], b: Decoder[B]): Decoder[Either[A, B]] = {
55     val l: Decoder[Either[A, B]] = a.map(Left.apply)
56     val r: Decoder[Either[A, B]] = b.map(Right.apply)
57     l.or(r)
58   }
59 
60   implicit def stringValueEncoder[A <: StringValue]: Encoder[A] = a => Json.fromString(a.value)
61 
62   implicit val urlEncoder: Encoder[URI] = Encoder[String].contramap(_.toString)
63   implicit val urlDecoder: Decoder[URI] = Decoder[String].emap { url =>
64     Try(new URI(url)) match {
65       case Success(parsed) => Right(parsed)
66       case Failure(_)      => Left(s"Not a valid URL: $url")
67     }
68   }
69 
70   implicit val durationEncoder: Encoder[scala.concurrent.duration.Duration] =
71     (a: scala.concurrent.duration.Duration) => Json.fromString(a.toString)
72   implicit val durationDecoder: Decoder[scala.concurrent.duration.Duration] =
73     Decoder.decodeString.emap { duration =>
74       Try(scala.concurrent.duration.Duration(duration)).toEither.left.map(_ => s"$duration is not a valid duration")
75     }
76 
77   @SuppressWarnings(Array("org.wartremover.warts.Recursion"))
78   implicit def circe2spray(t: Json): spray.json.JsValue =
79     t.fold(
80       spray.json.JsNull,
81       spray.json.JsBoolean(_),
82       x => spray.json.JsNumber(x.toDouble),
83       spray.json.JsString(_),
84       xs => spray.json.JsArray(xs.map(circe2spray)),
85       x  => spray.json.JsObject(x.keys.zip(x.values.map(circe2spray)).toMap)
86     )
87 
88   @SuppressWarnings(Array("org.wartremover.warts.Recursion"))
89   implicit def spray2circe(t: spray.json.JsValue): Json =
90     t match {
91       case spray.json.JsArray(elements) => Json.fromValues(elements.map(spray2circe))
92       case spray.json.JsObject(fields)  => Json.fromFields(fields.keys.zip(fields.values.map(spray2circe)))
93       case spray.json.JsFalse           => Json.False
94       case spray.json.JsTrue            => Json.True
95       case spray.json.JsNumber(value)   => Json.fromBigDecimal(value)
96       case spray.json.JsString(value)   => Json.fromString(value)
97       case spray.json.JsNull            => Json.Null
98     }
99 
100   @SuppressWarnings(Array("org.wartremover.warts.Throw"))
101   def circeCodec2sprayFormatter[A](implicit encoder: Encoder[A], decoder: Decoder[A]): spray.json.RootJsonFormat[A] =
102     new spray.json.RootJsonFormat[A] {
103       override def read(json: spray.json.JsValue): A =
104         decoder(HCursor.fromJson(json)) match {
105           case Left(error)  => throw error
106           case Right(value) => value
107         }
108       override def write(obj: A): spray.json.JsValue = encoder(obj)
109     }
110 }