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 cats.{Eq, Show}
23 import cats.data.{ValidatedNec, NonEmptyChain => Nec, NonEmptySeq => Nes}
24 import cats.implicits._
25 
26 import java.time.LocalDate
27 import jakarta.mail.internet.InternetAddress
28 import enumeratum.values.StringEnum
29 import eu.timepit.refined.auto._
30 import eu.timepit.refined.api.{Refined, Validate}
31 import eu.timepit.refined.boolean.And
32 import eu.timepit.refined.collection.NonEmpty
33 import grizzled.slf4j.Logging
34 import io.circe.generic.semiauto.deriveCodec
35 import io.circe.{Codec, Decoder, Encoder}
36 import org.jsoup.Jsoup
37 import org.jsoup.safety.{Cleaner, Safelist}
38 import org.make.core.Validator.ValidatedValue
39 import org.make.core.elasticsearch.ElasticsearchFieldName
40 import org.make.core.reference.Language
41 import org.make.core.technical.ValidatedUtils._
42 
43 import scala.util.matching.Regex
44 import scala.util.{Failure, Success, Try}
45 import scala.annotation.nowarn
46 
47 object Validation extends Logging {
48 
49   private def isEmail(str: String): Boolean =
50     Try(new InternetAddress(str).validate()).isSuccess
51 
52   private val passwordRegex: Regex = "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[^a-zA-Z0-9 ])(?!.* ).{8,}$".r
53 
54   private val colorRegex: Regex = "^#[0-9a-fA-F]{6}$".r
55 
56   private val postalCodeRegex: Regex = "^\\d{5}$".r
57 
58   private val uploadFileNameRegex: Regex = "[a-zA-Z0-9_.-]+".r
59 
60   val emailRegex: Regex = "^([\\w-]+(?:\\.[\\w-]+)*)@((?:[\\w-]+\\.)*\\w[\\w-]{0,66})\\.([a-z]{2,6}(?:\\.[a-z]{2})?)$".r
61 
62   val minAgeWithLegalConsent: Int = 8
63   val minLegalAgeForExternalProposal: Int = 18
64   private val maxAgeWithLegalConsent: Int = 16
65   val maxAge: Int = 120
66 
67   def validateOptional(maybeRequire: Option[Requirement]*): Unit = validate(maybeRequire.flatten: _*)
68 
69   @SuppressWarnings(Array("org.wartremover.warts.Throw"))
70   def validate(require: Requirement*): Unit = {
71     val messages: Seq[ValidationError] = require.flatMap { requirement =>
72       Try(requirement.condition()) match {
73         case Failure(e) =>
74           Seq(ValidationError(requirement.field, requirement.key, Option(e.getMessage)))
75         case Success(false) =>
76           Seq(ValidationError(requirement.field, requirement.key, Option(requirement.message())))
77         case _ => Nil
78       }
79     }
80     if (messages.nonEmpty) {
81       throw ValidationFailedError(messages)
82     }
83   }
84 
85   def validateField(field: String, key: String, condition: => Boolean, message: => String): Requirement =
86     Requirement(field, key, () => condition, () => message)
87 
88   // StringWithParsers -> .withMaxLength
89   def maxLength(
90     field: String,
91     maxLength: Int,
92     fieldValue: String,
93     message: Option[Int => String] = None
94   ): Requirement = {
95 
96     val computeLength: Int = {
97       Option(fieldValue).map(_.length).getOrElse(0)
98     }
99     val isValid = {
100       computeLength <= maxLength
101     }
102 
103     Requirement(field, "too_long", () => isValid, () => {
104       if (isValid) {
105         ""
106       } else {
107         message.map(_(computeLength)).getOrElse(s"$field should not be longer than $maxLength")
108       }
109     })
110   }
111 
112   // Should be discarded completely: nulls should not exist, and we have better (more specific)
113   // ways of handling Options
114   def mandatoryField(fieldName: String, fieldValue: => Any, message: Option[String] = None): Requirement = {
115     val condition: () => Boolean = () => {
116       val value = fieldValue
117       Option(value).isDefined && value != None
118     }
119     validateField(fieldName, "mandatory", condition(), message.getOrElse(s"$fieldName is mandatory"))
120   }
121 
122   // OptionWithParsers -> .getValidated
123   def requirePresent(fieldName: String, fieldValue: => Option[_], message: Option[String] = None): Requirement = {
124     validateField(fieldName, "mandatory", fieldValue.nonEmpty, message.getOrElse(s"$fieldName should not be empty"))
125   }
126 
127   // StringWithParsers -> .toValidHTML
128   def validateUserInput(fieldName: String, fieldValue: => String, message: Option[String]): Requirement = {
129     val condition: () => Boolean = () => {
130       new Cleaner(Safelist.none()).isValid(Jsoup.parse(fieldValue))
131     }
132     validateField(fieldName, "invalid_content", condition(), message.getOrElse(s"$fieldName is not a valid user input"))
133   }
134 
135   // To be replaced with OptionWithParsers -> .getValidated >>= StringWithParsers -> .toValidHTML
136   def validateOptionalUserInput(
137     fieldName: String,
138     fieldValue: => Option[String],
139     message: Option[String]
140   ): Requirement = {
141     val condition: () => Boolean = () => {
142       fieldValue.forall(value => new Cleaner(Safelist.none()).isValid(Jsoup.parse(value)))
143     }
144     validateField(fieldName, "invalid_content", condition(), message.getOrElse(s"$fieldName is not a valid user input"))
145   }
146 
147   // StringWithParsers -> .toSlug
148   def requireValidSlug(
149     fieldName: String,
150     fieldValue: => Option[String],
151     message: Option[String] = None
152   ): Requirement = {
153     validateField(
154       fieldName,
155       "invalid_slug",
156       fieldValue.getOrElse("") == SlugHelper.apply(fieldValue.getOrElse("")),
157       message.getOrElse(s"$fieldName should not be empty")
158     )
159   }
160 
161   // SeqWithParsers -> .toEmpty
162   def requireEmpty(fieldName: String, fieldValue: => Seq[_], message: Option[String] = None): Requirement = {
163     validateField(fieldName, "non_empty", fieldValue.isEmpty, message.getOrElse(s"$fieldName should be empty"))
164   }
165 
166   def requireNotPresent(fieldName: String, fieldValue: => Option[_], message: Option[String] = None): Requirement = {
167     validateField(fieldName, "non_empty", fieldValue.isEmpty, message.getOrElse(s"$fieldName should be empty"))
168   }
169 
170   // AnyWithParsers -> .isOneOf
171   def validChoices[T](
172     fieldName: String,
173     message: Option[String] = None,
174     userChoices: Seq[T],
175     validChoices: Seq[T]
176   ): Requirement = {
177     val condition: () => Boolean = () => {
178       userChoices.forall(validChoices.contains)
179     }
180     validateField(fieldName, "invalid_value", condition(), message.getOrElse(s"$fieldName is not valid"))
181   }
182 
183   // BirthDate -> .validatedAge
184   def validateAge(fieldName: String, userDateInput: Option[LocalDate], message: Option[String] = None): Requirement = {
185     val condition: Boolean =
186       userDateInput
187         .map(BirthDate(_))
188         .forall(_.isBetween(minAgeWithLegalConsent, maxAge))
189     validateField(
190       fieldName,
191       "invalid_age",
192       condition,
193       message.getOrElse(s"Invalid date: age must be between $minAgeWithLegalConsent and $maxAge")
194     )
195   }
196 
197   // BirthDate -> .validateLegalConsent
198   def validateLegalConsent(
199     fieldName: String,
200     userDateInput: LocalDate,
201     userLegalConsent: Option[Boolean],
202     message: Option[String] = None
203   ): Requirement = {
204     val condition: Boolean =
205       LocalDate.now().minusYears(maxAgeWithLegalConsent).plusDays(1).isAfter(userDateInput) ||
206         BirthDate(userDateInput).isBetween(minAgeWithLegalConsent, maxAgeWithLegalConsent) &&
207           userLegalConsent.contains(true)
208     validateField(fieldName, "legal_consent", condition, message.getOrElse(s"Field $fieldName must be approved."))
209   }
210 
211   def validateSort[T <: ElasticsearchFieldName](
212     fieldName: String
213   )(sort: T)(implicit stringEnum: StringEnum[T]): Requirement = {
214     val choices = stringEnum.values.filter(_.sortable)
215     Validation.validChoices(
216       fieldName = fieldName,
217       message = Some(s"Invalid sort. Got $sort but expected one of: ${choices.mkString("\"", "\", \"", "\"")}"),
218       Seq(sort),
219       choices
220     )
221   }
222 
223   def validateUploadFileName(fileName: String): Requirement = {
224     validateField(
225       "filename",
226       "invalid_filename",
227       uploadFileNameRegex.matches(fileName),
228       s"File name ${fileName} is invalid. The file name should only contains letters, numbers, hyphen, dot or underscore"
229     )
230   }
231 
232   final case class BirthDate(val birthDate: LocalDate) extends AnyVal {
233 
234     def isBetween(inclusiveMin: Int, exclusiveMax: Int): Boolean = {
235       LocalDate.now().minusYears(exclusiveMax).isBefore(birthDate) &&
236       LocalDate.now().minusYears(inclusiveMin).plusDays(1).isAfter(birthDate)
237     }
238 
239     def validatedAge(fieldName: String, message: Option[String] = None): ValidatedNec[ValidationError, BirthDate] =
240       if (isBetween(minAgeWithLegalConsent, maxAge))
241         this.validNec
242       else
243         ValidationError(
244           fieldName,
245           "invalid_age",
246           message.orElse(Some(s"Invalid date: age must be between $minAgeWithLegalConsent and $maxAge"))
247         ).invalidNec
248 
249     def validatedLegalConsent(
250       fieldName: String,
251       userLegalConsent: Option[Boolean]
252     ): ValidatedNec[ValidationError, BirthDate] =
253       if (LocalDate.now().minusYears(maxAgeWithLegalConsent).plusDays(1).isAfter(birthDate) ||
254           isBetween(minAgeWithLegalConsent, maxAgeWithLegalConsent) &&
255           userLegalConsent.contains(true))
256         this.validNec
257       else
258         ValidationError(
259           fieldName,
260           "legal_consent",
261           Some(s"${birthDate.toString} does not fit legal consent requirements")
262         ).invalidNec
263   }
264 
265   object BirthDate {
266 
267     def fromAge(age: Int): BirthDate =
268       BirthDate(DateHelper.computeBirthDate(age))
269   }
270 
271   implicit class LocalDateExt(val t: LocalDate) extends AnyVal {
272     def elapsedYears: Int = LocalDate.now().getYear() - t.getYear()
273   }
274 
275   implicit val birthDateDecoder: Decoder[BirthDate] = Decoder.decodeLocalDate.emap { t =>
276     if (minAgeWithLegalConsent until maxAge contains (t.elapsedYears))
277       Right(BirthDate(t))
278     else
279       Left(s"Invalid date: age must be between $minAgeWithLegalConsent and $maxAge")
280   }
281   implicit val birthDateEncoder: Encoder[BirthDate] = Encoder.encodeLocalDate.contramap(_.birthDate)
282 
283   final case class NonEmptyType[T](elem: T) extends AnyVal
284 
285   implicit class EmptyableWithParsers[A <: { def isEmpty: Boolean }](elem: A) {
286 
287     def toEmpty(fieldName: String, message: Option[String] = None): ValidatedNec[ValidationError, Unit] =
288       if (elem.isEmpty)
289         ().validNec
290       else
291         ValidationError(fieldName, "non_empty", message.orElse(Some("Element was not empty"))).invalidNec
292 
293     def toNonEmpty(fieldName: String, message: Option[String] = None): ValidatedNec[ValidationError, NonEmptyType[A]] =
294       if (elem.isEmpty)
295         ValidationError(fieldName, "empty", message.orElse(Some("Element was empty"))).invalidNec
296       else
297         NonEmptyType[A](elem).validNec
298   }
299 
300   final case class SeqSubset[A](values: Iterable[A], superset: Set[A])
301 
302   implicit class IterableWithParsers[A](it: Iterable[A]) {
303 
304     private lazy val valuesAsSet = it.toSet
305 
306     def toEmpty(fieldName: String, message: Option[String]): ValidatedNec[ValidationError, Nil.type] =
307       it match {
308         case Nil => Nil.validNec
309         case _ =>
310           ValidationError(fieldName, "empty_seq", message.orElse(Some("Iterable was not empty"))).invalidNec
311       }
312 
313     def toSubsetOf(choices: Set[A]): ValidatedNec[ValidationError, SeqSubset[A]] =
314       choices &~ valuesAsSet match {
315         case Nil =>
316           SeqSubset(it, choices).validNec
317         case rejections =>
318           ValidationError("values", s"Values ${rejections.mkString(",")} are not allowed").invalidNec
319       }
320 
321     @SuppressWarnings(Array("org.wartremover.warts.ListUnapply"))
322     def toNel(fieldName: String, key: String, message: Option[String]): ValidatedNec[ValidationError, Nes[A]] =
323       it match {
324         case head :: next =>
325           Nes(head, next).validNec
326         case _ =>
327           ValidationError(fieldName, key, Some(s"$fieldName must not be empty")).invalidNec
328       }
329   }
330 
331   final case class OneOf[A](value: A, allowedValues: Iterable[A])
332 
333   implicit class AnyWithParsers[A](val value: A) extends AnyVal {
334 
335     def toOneOf(
336       choices: Iterable[A],
337       fieldName: String,
338       message: Option[String] = None
339     ): ValidatedNec[ValidationError, OneOf[A]] =
340       if (choices.exists(_ == value)) OneOf(value, choices).validNec
341       else
342         ValidationError(fieldName, message.getOrElse(s"Value $value is not one of ${choices.mkString(",")}")).invalidNec
343 
344     def equalsValidated(other: A, fieldName: String, key: String = "not_equal", message: Option[String] = None)(
345       implicit E: Eq[A]
346     ): ValidatedNec[ValidationError, A] =
347       Either.cond(value === other, value, ValidationError(fieldName, key, message)).toValidatedNec
348 
349     def predicateValidated(
350       predicate: A => Boolean,
351       fieldName: String,
352       key: String,
353       message: Option[String] = None
354     ): ValidatedNec[ValidationError, A] =
355       Either.cond(predicate(value), value, ValidationError(fieldName, key, message)).toValidatedNec
356   }
357 
358   implicit class ElasticsearchFieldNameWithParsers[T <: ElasticsearchFieldName](val value: T) extends AnyVal {
359 
360     def sortValidated(fieldName: String, sort: T)(implicit E: StringEnum[T]): ValidatedNec[ValidationError, OneOf[T]] =
361       sort.toOneOf(E.values.filter(_.sortable), fieldName)
362   }
363 
364   final case class StringWithMinLength(value: String, minLength: Int)
365 
366   final case class StringWithMaxLength(value: String, maxLength: Int)
367 
368   final case class NonEmptyString(value: String) extends AnyVal
369 
370   final case class ValidHtml()
371   object ValidHtml {
372     @inline
373     @deprecated("There is no guarantee the parameter is html safe", since = "2023-09-20")
374     def fromStringUnsafe(t: String): String Refined ValidHtml = Refined.unsafeApply(t)
375   }
376 
377   implicit def validateHtml: Validate.Plain[String, ValidHtml] =
378     Validate.fromPredicate(
379       t => new Cleaner(Safelist.none()).isValid(Jsoup.parse(t)),
380       _ => "invalid user input",
381       ValidHtml()
382     )
383 
384   type Name = String Refined (ValidHtml And NonEmpty)
385 
386   final case class Email(value: String) extends AnyVal
387 
388   implicit val emailDecoder: Decoder[Email] = Decoder.decodeString.emap {
389     case t if isEmail(t) => Right(Email(t))
390     case _               => Left("Malformed email")
391   }
392   implicit val emailEncoder: Encoder[Email] = Encoder.encodeString.contramap(_.value)
393 
394   final case class Password(value: String) extends AnyVal
395 
396   implicit val passwordDecoder: Decoder[Password] = Decoder.decodeString.emap {
397     case t if passwordRegex.matches(t) => Right(Password(t))
398     case _ =>
399       Left("password must be at least 8 characters long including 1 figure, 1 uppercase and 1 special characters")
400   }
401   implicit val passwordEncoder: Encoder[Password] = Encoder.encodeString.contramap(_.value)
402 
403   final case class Slug()
404   object Slug {
405     @inline
406     @deprecated("There is no guarantee the parameter is a valid slug", since = "2023-09-20")
407     def fromStringUnsafe(t: String): String Refined Slug = Refined.unsafeApply(t)
408   }
409 
410   implicit val validateSlug: Validate.Plain[String, Slug] =
411     Validate.fromPredicate(
412       t => validateHtml.isValid(t) && SlugHelper.apply(t) === t,
413       t => s"${t} is not a valid slug",
414       Slug()
415     )
416 
417   final case class PostalCode(value: String) extends AnyVal
418 
419   implicit val postalCodeDecoder: Decoder[PostalCode] = Decoder.decodeString.emap {
420     case t if (postalCodeRegex.findFirstIn(t).isDefined) => Right(PostalCode(t))
421     case t                                               => Left(s"Invalid postal code $t. Must be formatted '01234'")
422   }
423   implicit val postalCodeEncoder: Encoder[PostalCode] = Encoder.encodeString.contramap(_.value)
424 
425   final case class Colour()
426   implicit val validateColour: Validate.Plain[String, Colour] =
427     Validate.fromPredicate(colorRegex.matches(_), t => s"$t is not a valid colour", Colour())
428   object Colour {
429     @inline
430     @deprecated("There is no guarantee the parameter is a valid colour", since = "2023-09-20")
431     def fromStringUnsafe(t: String): String Refined Colour = Refined.unsafeApply(t)
432 
433     // NOTE: cannot check at compile-time that our string is a valid colour:
434     // https://github.com/fthomas/refined/blob/master/modules/docs/macro_pitfalls.md#solution-2
435     @nowarn("cat=deprecation")
436     val black: String Refined Colour = Colour.fromStringUnsafe("#000000")
437   }
438 
439   final case object EmptyString
440 
441   implicit class StringWithParsers(val value: String) extends AnyVal {
442 
443     def toEmpty(fieldName: String, message: Option[String] = None): ValidatedNec[ValidationError, EmptyString.type] =
444       value match {
445         case "" => EmptyString.validNec
446         case _ =>
447           ValidationError(fieldName, "empty_string", message.orElse(Some("String was not empty"))).invalidNec
448       }
449 
450     def withMinLength(
451       minLength: Int,
452       fieldName: String,
453       language: Option[Language] = None,
454       message: Option[String] = None
455     ): ValidatedNec[ValidationError, StringWithMinLength] =
456       if (value.length >= minLength)
457         StringWithMinLength(value, minLength).validNec
458       else {
459         val forLanguage = language.fold("")(l => s" for the language : ${l.value}")
460         ValidationError(
461           fieldName,
462           "too_short",
463           message.orElse(Some(s"$fieldName should not be shorter than $minLength$forLanguage"))
464         ).invalidNec
465       }
466 
467     def withMaxLength(
468       maxLength: Int,
469       fieldName: String,
470       language: Option[Language] = None,
471       message: Option[String] = None
472     ): ValidatedNec[ValidationError, StringWithMaxLength] =
473       if (value.length <= maxLength)
474         StringWithMaxLength(value, maxLength).validNec
475       else {
476         val forLanguage = language.fold("")(l => s" for the language : ${l.value}")
477         ValidationError(
478           fieldName,
479           "too_long",
480           message.orElse(Some(s"$fieldName should not be longer than $maxLength$forLanguage"))
481         ).invalidNec
482       }
483 
484     def toNonEmpty(fieldName: String, message: Option[String] = None): ValidatedNec[ValidationError, NonEmptyString] =
485       if (value.nonEmpty)
486         NonEmptyString(value).validNec
487       else
488         ValidationError(fieldName, "empty", message.orElse(Some(s"$fieldName should not be an empty string"))).invalidNec
489 
490     def toSanitizedInput(
491       fieldName: String,
492       message: Option[String] = None
493     ): ValidatedNec[ValidationError, String Refined ValidHtml] =
494       if (new Cleaner(Safelist.none()).isValid(Jsoup.parse(value)))
495         ValidHtml.fromStringUnsafe(value).validNec
496       else
497         ValidationError("user_input", "User provided invalid HTML").invalidNec
498 
499     def toEmail: ValidatedNec[ValidationError, Email] =
500       value
501         .toSanitizedInput("email")
502         .flatMap(
503           v =>
504             if (isEmail(v.value))
505               Email(v.value).validNec
506             else
507               ValidationError("email", "invalid_email", Some("email is not a valid email")).invalidNec
508         )
509 
510     def toPassword: ValidatedNec[ValidationError, Password] =
511       value
512         .toSanitizedInput("password")
513         .flatMap(
514           v =>
515             if (passwordRegex.matches(v.value))
516               Password(v.value).validNec
517             else
518               ValidationError(
519                 "password",
520                 "invalid_password",
521                 Some(
522                   "password must be at least 8 characters long including 1 figure, 1 uppercase and 1 special characters"
523                 )
524               ).invalidNec
525         )
526 
527     def toSlug(message: Option[String] = None): ValidatedNec[ValidationError, String Refined Slug] =
528       value
529         .toSanitizedInput("slug")
530         .flatMap(
531           v =>
532             if (SlugHelper.apply(v.value) === v.value)
533               Slug.fromStringUnsafe(v.value).validNec
534             else
535               ValidationError("slug", s"${v.value} is not a valid slug").invalidNec
536         )
537 
538     def toValidAge(message: Option[String] = None): ValidatedNec[ValidationError, Int] =
539       Try(value.toInt) match {
540         case Success(age) if age >= minLegalAgeForExternalProposal => age.validNec
541         case Success(_) =>
542           ValidationError(
543             "age",
544             "invalid_age",
545             message.orElse(Some(s"$value must be over $minLegalAgeForExternalProposal"))
546           ).invalidNec
547         case Failure(_) => ValidationError("age", "invalid_format", Some(s"'$value' is not a valid number")).invalidNec
548       }
549 
550     def toPostalCode: ValidatedNec[ValidationError, PostalCode] =
551       if (postalCodeRegex.findFirstIn(value).isDefined)
552         PostalCode(value).validNec
553       else
554         ValidationError(
555           "postalCode",
556           "invalid_postal_code",
557           Some(s"Invalid postal code $value. Must be formatted '01234'")
558         ).invalidNec
559 
560     def toColour(
561       fieldName: String,
562       message: Option[String] = None
563     ): ValidatedNec[ValidationError, String Refined Colour] =
564       if (colorRegex.matches(value)) Colour.fromStringUnsafe(value).validNec
565       else ValidationError(fieldName, "invalid_colour", message).invalidNec
566   }
567 
568   implicit class OptionWithParsers[A](val opt: Option[A]) {
569 
570     def getValidated(
571       fieldName: String,
572       key: Option[String] = None,
573       message: Option[String] = None
574     ): ValidatedNec[ValidationError, A] =
575       opt match {
576         case Some(value) => value.validNec
577         case None        => ValidationError(fieldName, key.getOrElse("value_absent"), message).invalidNec
578       }
579 
580     def getNone(fieldName: String, message: Option[String] = None): ValidatedNec[ValidationError, Unit] =
581       opt match {
582         case Some(value) => ValidationError(fieldName, "value_present", message).invalidNec
583         case None        => ().validNec
584       }
585   }
586 
587   implicit class LongWithParsers(val value: Long) {
588     def max(fieldName: String, maxValue: Long, message: Option[String] = None): ValidatedNec[ValidationError, Long] = {
589       if (value > maxValue) {
590         ValidationError(fieldName, "exceeds_max", message.orElse(Some(s"$fieldName should be lower than $maxValue"))).invalidNec
591       } else {
592         value.validNec
593       }
594     }
595   }
596 
597   implicit class MapWithParser(val map: Map[String, String]) extends AnyVal {
598     def getNonEmptyString(fieldName: String, message: Option[String]): ValidatedNec[ValidationError, NonEmptyString] =
599       map.get(fieldName).getValidated(fieldName, None, message).andThen(_.toNonEmpty(fieldName, message))
600   }
601 }
602 
603 final case class Requirement(field: String, key: String, condition: () => Boolean, message: () => String)
604 
605 trait Validator[T] {
606   def validate(value: T): ValidatedValue[T]
607 }
608 
609 object Validator {
610   def apply[T](validator: T => ValidatedValue[T]): Validator[T] = (value: T) => validator(value)
611 
612   type ValidatedValue[T] = ValidatedNec[ValidationError, T]
613 }
614 
615 final case class ValidationFailedError(errors: Seq[ValidationError]) extends Exception {
616 
617   override def getMessage: String = errors.mkString("[", ",", "]")
618 }
619 
620 object ValidationFailedError {
621 
622   def apply(nec: Nec[ValidationError]): ValidationFailedError =
623     new ValidationFailedError(nec.toList)
624 }
625 
626 final case class ValidationError(field: String, key: String, message: Option[String] = None) {
627 
628   def toThrowable: Throwable = {
629     val errMsg = message.getOrElse(s"$field value '$key' was invalid")
630     new IllegalArgumentException(errMsg)
631   }
632 }
633 
634 object ValidationError {
635 
636   implicit val codec: Codec[ValidationError] = deriveCodec
637 
638   implicit val show: Show[ValidationError] = Show.show(_.toThrowable.toString)
639 }
640 
641 final case class SanitizedHtml(html: String) extends AnyRef
642 
643 object SanitizedHtml {
644 
645   private val cleaner = new Cleaner(Safelist.basic)
646 
647   def fromString(unsafeHtml: String, maxTextLength: Option[Int] = None): Try[SanitizedHtml] = {
648     val sanitized = cleaner.clean(Jsoup.parseBodyFragment(unsafeHtml))
649     maxTextLength match {
650       case Some(maxLength) if sanitized.text().length > maxLength =>
651         Failure(new Error(s"Text exceeded $maxLength characters"))
652       case _ =>
653         Success(new SanitizedHtml(sanitized.body.children.toString))
654     }
655   }
656 }