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.data.{NonEmptyList, Validated, ValidatedNec}
23 import cats.implicits._
24 import io.circe.{Decoder, DecodingFailure, HCursor}
25 import org.make.core.ValidationError
26 import org.make.core.reference.Language
27 import shapeless.{HList, LabelledGeneric}
28 import shapeless.ops.record.{Keys, Values}
29 import scala.annotation.tailrec
30 
31 object MultilingualUtils {
32 
33   def hasRequiredTranslationsFromCsv(
34     languagesSet: Set[Language],
35     translations: Option[Multilingual[String]],
36     originalLanguage: Option[Language],
37     lineNumber: Int
38   ): ValidatedNec[ValidationError, Option[Multilingual[String]]] = {
39     val languages = originalLanguage.toList.toSet ++ translations.toList
40       .toSet[Multilingual[String]]
41       .flatMap(_.providedLanguages)
42     languagesSet == languages match {
43       case true => translations.validNec
44       case false if languagesSet.sizeIs > languages.size =>
45         val missing = languagesSet.diff(languages)
46         ValidationError(
47           "contents",
48           "missing_translation",
49           Some(s"There is a missing translations for ${missing.mkString(",")} on line $lineNumber")
50         ).invalidNec
51       case false if languagesSet.sizeIs < languages.size =>
52         val tooMany = languages.diff(languagesSet)
53         ValidationError(
54           "contents",
55           "too_many_translation",
56           Some(s"There is too many translations : ${tooMany.mkString(",")} on line $lineNumber")
57         ).invalidNec
58       case _ =>
59         val mismatch = languages.diff(languagesSet)
60         ValidationError(
61           "content",
62           "mismatch_translation",
63           Some(s"There is a translations mismatch : ${mismatch.mkString(",")} on line $lineNumber")
64         ).invalidNec
65     }
66   }
67 
68   def hasRequiredTranslations(
69     languagesSet: Set[Language],
70     multilinguals: List[(Multilingual[_], String)]
71   ): ValidatedNec[ValidationError, Unit] =
72     multilinguals.traverse_({
73       case (field, fieldName) =>
74         languagesSet == field.providedLanguages match {
75           case true => ().validNec
76           case false if languagesSet.sizeIs > field.providedLanguages.size =>
77             val missing = languagesSet.diff(field.providedLanguages)
78             ValidationError(
79               fieldName,
80               "missing_translation",
81               Some(s"Field $fieldName is missing translations for ${missing.mkString(",")}")
82             ).invalidNec
83           case false if languagesSet.sizeIs < field.providedLanguages.size =>
84             val tooMany = field.providedLanguages.diff(languagesSet)
85             ValidationError(
86               fieldName,
87               "too_many_translation",
88               Some(s"Field $fieldName has too many translations : ${tooMany.mkString(",")}")
89             ).invalidNec
90           case _ =>
91             val mismatch = field.providedLanguages.diff(languagesSet)
92             ValidationError(
93               fieldName,
94               "mismatch_translation",
95               Some(s"Field $fieldName has mismatch translations : ${mismatch.mkString(",")}")
96             ).invalidNec
97         }
98     })
99 
100   def validateDecoder[A](decoder: Decoder[A])(
101     langsF: A    => Set[Language],
102     requiredF: A => Seq[(Multilingual[_], String)],
103     optionalF: A => Seq[Option[(Multilingual[_], String)]]
104   ): Decoder[A] =
105     decoder.flatMap { t =>
106       val langs = langsF(t)
107 
108       def findErrors(c: HCursor) =
109         (requiredF(t).iterator ++ optionalF(t).iterator.flatten).flatMap {
110           case (field, fieldName) =>
111             langs.diff(field.providedLanguages) match {
112               case missing if missing.nonEmpty =>
113                 val ac = c.downField(fieldName)
114                 Some(DecodingFailure(s"Missing translations: ${missing.mkString(", ")}", ac.history))
115 
116               case _ =>
117                 None
118             }
119         }
120 
121       new Decoder[A] {
122         override def apply(c: HCursor): Decoder.Result[A] =
123           findErrors(c).nextOption().toLeft(t)
124 
125         override def decodeAccumulating(c: HCursor): Decoder.AccumulatingResult[A] =
126           findErrors(c).toList match {
127             case hd :: tl =>
128               Validated.Invalid(NonEmptyList(hd, tl))
129 
130             case Nil =>
131               Validated.Valid(t)
132           }
133       }
134     }
135 
136   /**
137     * Enhances an instance of `Decoder[A]` by checking every fields of `A` which has a
138     * type of `Multilingual[_]`, or `Option[Multilingual[_]]`. Every one of these fields
139     * must contain a translation for every given languages passed as parameter.
140     *
141     * You have to pass as parameter `langsF` a function `A => Set[Language]` since it
142     * generally depends upon values in `A` instead of a static set of languages.
143     */
144   def genDecoder[A, Repr <: HList](
145     decoder: Decoder[A],
146     langsF: A => Set[Language]
147   )(implicit gen: LabelledGeneric.Aux[A, Repr], keys: Keys[Repr], values: Values[Repr]): Decoder[A] =
148     decoder.flatMap(a => new GenDecoder(a, langsF(a)))
149 
150   private class GenDecoder[A, Repr <: HList](a: A, langs: Set[Language])(
151     implicit gen: LabelledGeneric.Aux[A, Repr],
152     keys: Keys[Repr],
153     values: Values[Repr]
154   ) extends Decoder[A] {
155 
156     override def apply(c: HCursor): Decoder.Result[A] = {
157 
158       /**
159         * Actually validate a `Multilingual[_]` instance, which is actually stored
160         * in some field `k` of `A`.
161         */
162       def doValidate(x: Multilingual[_], k: Symbol): Either[DecodingFailure, Unit] =
163         langs.diff(x.providedLanguages) match {
164           case missing if missing.nonEmpty =>
165             Left(DecodingFailure(s"Missing translations: ${missing.mkString(", ")}", c.downField(k.name).history))
166           case _ => Right(())
167         }
168 
169       /**
170         * Scan through every fields of `A` to find instances of :
171         *   - `Multilingual[_]`,
172         *   - `Option[Multilingual[_]]`.
173         */
174       @SuppressWarnings(Array("org.wartremover.warts.TraversableOps", "org.wartremover.warts.IterableOps"))
175       @tailrec
176       def recApply(ks: List[Any], xs: List[Any]): Decoder.Result[A] =
177         ks.headOption.zip(xs.headOption) match {
178           case None => Right(a)
179 
180           case Some((k: Symbol, x: Multilingual[_])) =>
181             doValidate(x, k) match {
182               case Left(err) =>
183                 Left(err)
184               case _ =>
185                 recApply(ks.tail, xs.tail)
186             }
187 
188           case Some((k: Symbol, Some(x: Multilingual[_]))) =>
189             doValidate(x, k) match {
190               case Left(err) =>
191                 Left(err)
192               case _ =>
193                 recApply(ks.tail, xs.tail)
194             }
195 
196           case _ => recApply(ks.tail, xs.tail)
197         }
198 
199       // Fetch reflective information generated at compile-time by shapeless,
200       // and start to validate `a`.
201       recApply(keys().runtimeList, values(gen.to(a)).runtimeList)
202     }
203 
204   }
205 }