1 /*
2  *  Make.org Core API
3  *  Copyright (C) 2020 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.technical
21 
22 import cats.implicits._
23 import eu.timepit.refined.api.Refined
24 import eu.timepit.refined.collection.NonEmpty
25 import org.make.core.reference.Language
26 
27 final case class Multilingual[T](private val pairs: Map[Language, T]) {
28 
29   override def toString: String =
30     pairs.map {
31       case (Language(l), v) => s"$l: $v"
32     }.mkString("\n")
33 
34   def getTranslation(lang: Language): Option[T] =
35     pairs.get(lang)
36 
37   def getTranslationUnsafe(lang: Language): T =
38     pairs(lang)
39 
40   def addTranslation(lang: Language, translation: T): Multilingual[T] =
41     new Multilingual[T](pairs.updated(lang, translation))
42 
43   def mapTranslations[U](fn: T => U): Multilingual[U] =
44     new Multilingual[U](pairs.view.mapValues(fn).toMap)
45 
46   def toMap: Map[Language, T] =
47     pairs
48 
49   def providedLanguages: Set[Language] =
50     pairs.keys.toSet
51 
52   def translations: LazyList[T] =
53     pairs.values.to(LazyList)
54 
55   def isEmpty: Boolean =
56     pairs.isEmpty
57 }
58 
59 object Multilingual {
60 
61   private val BaseLanguage = Language("fr")
62 
63   def empty[T]: Multilingual[T] =
64     new Multilingual[T](Map.empty)
65 
66   def apply[T](elements: (Language, T)*): Multilingual[T] =
67     new Multilingual[T](Map(elements: _*))
68 
69   @SuppressWarnings(Array("org.wartremover.warts.Null"))
70   def fromMap[T](elements: Map[String, T]): Multilingual[T] = elements match {
71     case null => new Multilingual[T](Map.empty)
72     case _    => new Multilingual[T](elements.map(_.bimap(Language(_), identity)))
73   }
74 
75   def fromLanguagesMap[T](elements: Map[Language, T]): Multilingual[T] =
76     new Multilingual[T](elements)
77 
78   def fromDefault[T](value: T): Multilingual[T] =
79     apply(BaseLanguage -> value)
80 
81   import io.circe.syntax._
82   import io.circe.{Decoder, Encoder}
83   import io.circe.parser.decode
84   import io.circe.refined._
85 
86   implicit def circeEncoder[T: Encoder]: Encoder[Multilingual[T]] =
87     _.toMap.map(_.bimap(_.value, identity)).asJson
88 
89   implicit def circeDecoder[T: Decoder]: Decoder[Multilingual[T]] =
90     Decoder.decodeMap[String, T].map(Multilingual.fromMap)
91 
92   import scalikejdbc.Binders
93 
94   def multilingualConverter[T: Decoder: Encoder]: Binders[Multilingual[T]] =
95     Binders.string.xmap(decode[Multilingual[T]](_).getOrElse(Multilingual.empty), circeEncoder.apply(_).noSpaces)
96 
97   def optMultilingualConverter[T: Decoder: Encoder]: Binders[Option[Multilingual[T]]] =
98     Binders.string.xmap(
99       l => decode[Option[Map[String, T]]](l).getOrElse(None).map(Multilingual.fromMap),
100       _.map(_.toMap.map(_.bimap(_.value, identity))).asJson.noSpaces
101     )
102 
103   implicit val multilingualNonEmptyBinder: Binders[Multilingual[String Refined NonEmpty]] =
104     multilingualConverter[String Refined NonEmpty]
105   implicit val optMultilingualNonEmptyBinder: Binders[Option[Multilingual[String Refined NonEmpty]]] =
106     optMultilingualConverter[String Refined NonEmpty]
107 
108   implicit val multilingualBinder: Binders[Multilingual[String]] = multilingualConverter[String]
109 
110   implicit val optMultilingualBinder: Binders[Option[Multilingual[String]]] = optMultilingualConverter[String]
111 
112   import eu.timepit.refined.api.Refined
113   import eu.timepit.refined.auto._
114   import eu.timepit.refined.collection.MaxSize
115   import io.circe.refined._
116 
117   implicit val refined130StringMapConverter: Binders[Multilingual[String Refined MaxSize[130]]] =
118     multilingualConverter[String Refined MaxSize[130]]
119   implicit val refined130OptStringMapConverter: Binders[Option[Multilingual[String Refined MaxSize[130]]]] =
120     optMultilingualConverter[String Refined MaxSize[130]]
121   implicit val refined20StringMapConverter: Binders[Multilingual[String Refined MaxSize[20]]] =
122     multilingualConverter[String Refined MaxSize[20]]
123   implicit val refined20OptStringMapConverter: Binders[Option[Multilingual[String Refined MaxSize[20]]]] =
124     optMultilingualConverter[String Refined MaxSize[20]]
125   implicit val refined150StringMapConverter: Binders[Multilingual[String Refined MaxSize[150]]] =
126     multilingualConverter[String Refined MaxSize[150]]
127   implicit val refined150OptStringMapConverter: Binders[Option[Multilingual[String Refined MaxSize[150]]]] =
128     optMultilingualConverter[String Refined MaxSize[150]]
129 
130   import spray.json._
131 
132   implicit def multilingualFormatter[T](
133     implicit reader: JsonReader[T],
134     writer: JsonWriter[T]
135   ): RootJsonFormat[Multilingual[T]] =
136     new RootJsonFormat[Multilingual[T]] {
137 
138       @SuppressWarnings(Array("org.wartremover.warts.Throw"))
139       override def read(json: JsValue): Multilingual[T] =
140         json match {
141           case JsObject(m) => new Multilingual(m.map(_.bimap(Language(_), reader.read(_))))
142           case other       => throw new IllegalArgumentException(s"Unable to convert $other")
143         }
144 
145       override def write(obj: Multilingual[T]): JsValue =
146         JsObject(obj.toMap.map(_.bimap(_.value, writer.write)))
147     }
148 
149   import com.github.plokhotnyuk.jsoniter_scala.core.{
150     JsonReader     => JsoniterReader,
151     JsonWriter     => JsoniterWriter,
152     JsonValueCodec => JsoniterValueCodec
153   }
154   import com.github.plokhotnyuk.jsoniter_scala.macros.{JsonCodecMaker => JsoniterCodecMaker}
155 
156   @SuppressWarnings(Array("org.wartremover.warts.Null", "org.wartremover.warts.AsInstanceOf"))
157   def makeCodec[T: JsoniterValueCodec]: JsoniterValueCodec[Multilingual[T]] =
158     new JsoniterValueCodec[Multilingual[T]] {
159 
160       private val mapCodec: JsoniterValueCodec[Map[String, T]] =
161         JsoniterCodecMaker.make[Map[String, T]]
162 
163       def decodeValue(in: JsoniterReader, default: Multilingual[T]): Multilingual[T] =
164         Multilingual.fromMap(mapCodec.decodeValue(in, null))
165 
166       def encodeValue(value: Multilingual[T], out: JsoniterWriter): Unit =
167         mapCodec.encodeValue(value.toMap.map(_.bimap(_.value, identity)), out)
168 
169       def nullValue: Multilingual[T] =
170         null.asInstanceOf[Multilingual[T]]
171     }
172 }