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.api.technical
21 
22 import cats.data.NonEmptyList
23 import enumeratum.values.{StringEnum, StringEnumEntry}
24 import enumeratum.{Enum, EnumEntry}
25 import eu.timepit.refined.api.{RefType, Refined, Validate}
26 import eu.timepit.refined.refineV
27 import io.circe.{KeyDecoder, KeyEncoder}
28 import scalikejdbc.{Binders, ParameterBinderFactory, TypeBinder}
29 import org.make.core.StringValue
30 import org.make.core.technical.Multilingual
31 import org.make.core.crmTemplate.{CrmLanguageTemplateId, CrmQuestionTemplateId, CrmTemplateKind, TemplateId}
32 import org.make.core.demographics.{DemographicsCard, DemographicsCardId, LabelsValue}
33 import org.make.core.feature.{ActiveFeatureId, FeatureId}
34 import org.make.core.operation.OperationId
35 import org.make.core.question.QuestionId
36 import org.make.core.reference.{Country, Language}
37 import org.make.core.sequence.{ExplorationSequenceConfigurationId, ExplorationSortAlgorithm, SequenceKind}
38 import org.make.core.tag.{TagId, TagTypeId}
39 import org.make.core.user.{OidcInfo, UserId, UserType}
40 import org.make.core.widget.{SourceId, Widget, WidgetId}
41 
42 import java.sql.{PreparedStatement, ResultSet}
43 
44 object ScalikeSupport {
45 
46   def enumBinders[A <: EnumEntry](implicit basicEnum: Enum[A]): Binders[A] =
47     Binders.string.xmap(basicEnum.withName, _.entryName)
48 
49   implicit val crmTemplateKindBinders: Binders[CrmTemplateKind] = enumBinders
50   implicit val demographicsCardLayoutBinders: Binders[DemographicsCard.Layout] = enumBinders
51   implicit val widgetVersionBinders: Binders[Widget.Version] = enumBinders
52   implicit val sequenceKindBinders: Binders[SequenceKind] = enumBinders
53 
54   implicit def stringEnumBinders[A <: StringEnumEntry](implicit stringEnum: StringEnum[A]): Binders[A] =
55     Binders.string.xmap(stringEnum.withValue, _.value)
56 
57   implicit def stringEnumEntryParameterBinderFactory[A <: StringEnumEntry, B <: A]: ParameterBinderFactory[B] =
58     ParameterBinderFactory.stringParameterBinderFactory.contramap(_.value)
59 
60   def stringValueBinders[A <: StringValue](f: String => A): Binders[A] = Binders.string.xmap(f, _.value)
61 
62   implicit val activeFeatureIdBinders: Binders[ActiveFeatureId] = stringValueBinders(ActiveFeatureId.apply)
63   implicit val crmLanguageTemplateIdBinders: Binders[CrmLanguageTemplateId] = stringValueBinders(
64     CrmLanguageTemplateId.apply
65   )
66   implicit val crmQuestionTemplateIdBinders: Binders[CrmQuestionTemplateId] = stringValueBinders(
67     CrmQuestionTemplateId.apply
68   )
69   implicit val countryBinders: Binders[Country] = stringValueBinders(Country.apply)
70   implicit val demographicsCardIdBinders: Binders[DemographicsCardId] = stringValueBinders(DemographicsCardId.apply)
71   implicit val featureIdBinders: Binders[FeatureId] = stringValueBinders(FeatureId.apply)
72   implicit val languageBinders: Binders[Language] = stringValueBinders(Language.apply)
73   implicit val operationIdBinders: Binders[OperationId] = stringValueBinders(OperationId.apply)
74   implicit val questionIdBinders: Binders[QuestionId] = stringValueBinders(QuestionId.apply)
75   implicit val sourceIdBinders: Binders[SourceId] = stringValueBinders(SourceId.apply)
76   implicit val tagIdBinders: Binders[TagId] = stringValueBinders(TagId.apply)
77   implicit val tagTypeIdBinders: Binders[TagTypeId] = stringValueBinders(TagTypeId.apply)
78   implicit val templateIdBinders: Binders[TemplateId] = stringValueBinders(TemplateId.apply)
79   implicit val userIdBinders: Binders[UserId] = stringValueBinders(UserId.apply)
80   implicit val widgetIdBinders: Binders[WidgetId] = stringValueBinders(WidgetId.apply)
81   implicit val ExplorationSequenceConfigurationIdBinders: Binders[ExplorationSequenceConfigurationId] =
82     stringValueBinders(ExplorationSequenceConfigurationId.apply)
83 
84   implicit val userTypeBinders: Binders[UserType] = stringEnumBinders[UserType]
85   implicit val explorationSortAlgorithmBinders: Binders[ExplorationSortAlgorithm] = {
86     stringEnumBinders[ExplorationSortAlgorithm]
87   }
88 
89   /*
90    * The following code is a copy-paste from https://github.com/katainaka0503/scalikejdbc-refined
91    **/
92   implicit def refinedParameterBinderFactory[T, P, F[_, _]](
93     implicit
94     based: ParameterBinderFactory[T],
95     refType: RefType[F]
96   ): ParameterBinderFactory[F[T, P]] =
97     based.contramap(refType.unwrap)
98 
99   implicit def refinedTypeBinder[T, P](
100     implicit validate: Validate[T, P],
101     based: TypeBinder[T]
102   ): TypeBinder[Refined[T, P]] =
103     based.map(refineV[P].unsafeFrom(_))
104 
105   import io.circe.{Decoder, Encoder}
106   import io.circe.parser.decode
107   import io.circe.syntax._
108 
109   @SuppressWarnings(Array("org.wartremover.warts.Throw", "org.wartremover.warts.TryPartial"))
110   def jsonNelBinder[T: Encoder: Decoder]: Binders[NonEmptyList[T]] =
111     Binders.string.xmap(decode[NonEmptyList[T]](_).toTry.get, _.asJson.noSpaces)
112 
113   @SuppressWarnings(Array("org.wartremover.warts.AsInstanceOf"))
114   implicit val languagesTypeBinder: TypeBinder[NonEmptyList[Language]] = new TypeBinder[NonEmptyList[Language]] {
115     def apply(rs: ResultSet, idx: Int): NonEmptyList[Language] =
116       NonEmptyList.fromListUnsafe(rs.getArray(idx).getArray.asInstanceOf[Array[String]].toList.map(Language.apply))
117 
118     def apply(rs: ResultSet, label: String): NonEmptyList[Language] =
119       NonEmptyList.fromListUnsafe(rs.getArray(label).getArray.asInstanceOf[Array[String]].toList.map(Language.apply))
120   }
121   implicit val languagesParameterBinder: ParameterBinderFactory[NonEmptyList[Language]] = ParameterBinderFactory {
122     value => (stmt, idx) =>
123       stmt.setArray(idx, stmt.getConnection.createArrayOf("VARCHAR", value.map(_.value).toList.toArray))
124   }
125 
126   implicit val mapConverter: Binders[Map[String, String]] =
127     Binders.string.xmap(decode[Map[String, String]](_).getOrElse(Map.empty), _.asJson.noSpaces)
128 
129   def optCustomMapConverter[K: KeyDecoder: KeyEncoder, V: Decoder: Encoder]: Binders[Option[Map[K, V]]] =
130     Binders.string.xmap(l => decode[Option[Map[K, V]]](l).toOption.flatten, _.asJson.noSpaces)
131 
132   implicit val oidcInfosParameterBinder: ParameterBinderFactory[Option[Map[OperationId, OidcInfo]]] =
133     ParameterBinderFactory { oidcInfos => (stmt: PreparedStatement, idx: Int) =>
134       stmt.setObject(idx, oidcInfos.asJson.noSpaces)
135     }
136 
137   implicit val labelValuesBinder: Binders[LabelsValue] =
138     Binders.string.xmap(decode[LabelsValue](_).getOrElse(LabelsValue(Multilingual.empty, "")), _.asJson.noSpaces)
139 }