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.api.personality
21 
22 import cats.data.NonEmptyList
23 import cats.implicits._
24 import org.make.api.extensions.MakeDBExecutionContextComponent
25 import org.make.api.personality.DefaultPersistentPersonalityRoleFieldServiceComponent.PersistentPersonalityRoleField
26 import org.make.api.technical.DatabaseTransactions._
27 import org.make.api.technical.{PersistentCompanion, ShortenedNames}
28 import org.make.api.technical.PersistentServiceUtils.sortOrderQuery
29 import org.make.api.technical.ScalikeSupport._
30 import org.make.core.technical.Pagination
31 import org.make.core.personality.{FieldType, PersonalityRoleField, PersonalityRoleFieldId, PersonalityRoleId}
32 import org.make.core.Order
33 import scalikejdbc._
34 
35 import scala.concurrent.Future
36 
37 trait DefaultPersistentPersonalityRoleFieldServiceComponent extends PersistentPersonalityRoleFieldServiceComponent {
38   this: MakeDBExecutionContextComponent =>
39 
40   override lazy val persistentPersonalityRoleFieldService: DefaultPersistentPersonalityRoleFieldService =
41     new DefaultPersistentPersonalityRoleFieldService
42 
43   class DefaultPersistentPersonalityRoleFieldService extends PersistentPersonalityRoleFieldService with ShortenedNames {
44 
45     private val personalityRoleFieldAlias = PersistentPersonalityRoleField.alias
46 
47     private val column = PersistentPersonalityRoleField.column
48 
49     override def persist(personalityRoleField: PersonalityRoleField): Future[PersonalityRoleField] = {
50       implicit val context: EC = writeExecutionContext
51       Future(NamedDB("WRITE").retryableTx { implicit session =>
52         withSQL {
53           insert
54             .into(PersistentPersonalityRoleField)
55             .namedValues(
56               column.id -> personalityRoleField.personalityRoleFieldId.value,
57               column.personalityRoleId -> personalityRoleField.personalityRoleId.value,
58               column.name -> personalityRoleField.name,
59               column.fieldType -> personalityRoleField.fieldType,
60               column.required -> personalityRoleField.required
61             )
62         }.execute()
63       }).as(personalityRoleField)
64     }
65 
66     override def modify(personalityRoleField: PersonalityRoleField): Future[PersonalityRoleField] = {
67       implicit val context: EC = writeExecutionContext
68       Future(NamedDB("WRITE").retryableTx { implicit session =>
69         withSQL {
70           update(PersistentPersonalityRoleField)
71             .set(
72               column.name -> personalityRoleField.name,
73               column.fieldType -> personalityRoleField.fieldType,
74               column.required -> personalityRoleField.required
75             )
76             .where(sqls.eq(column.id, personalityRoleField.personalityRoleFieldId.value))
77         }.execute()
78       }).as(personalityRoleField)
79     }
80 
81     override def getById(
82       personalityRoleFieldId: PersonalityRoleFieldId,
83       personalityRoleId: PersonalityRoleId
84     ): Future[Option[PersonalityRoleField]] = {
85       implicit val context: EC = readExecutionContext
86       Future(NamedDB("READ").retryableTx { implicit session =>
87         withSQL {
88           select
89             .from(PersistentPersonalityRoleField.as(personalityRoleFieldAlias))
90             .where(
91               sqls
92                 .eq(column.id, personalityRoleFieldId.value)
93                 .and(sqls.eq(column.personalityRoleId, personalityRoleId.value))
94             )
95         }.map(PersistentPersonalityRoleField.apply()).single()
96       }).map(_.map(_.toPersonalityRoleField))
97     }
98 
99     override def find(
100       offset: Pagination.Offset,
101       end: Option[Pagination.End],
102       sort: Option[String],
103       order: Option[Order],
104       maybePersonalityRoleId: Option[PersonalityRoleId],
105       maybeName: Option[String],
106       maybeFieldType: Option[FieldType],
107       maybeRequired: Option[Boolean]
108     ): Future[Seq[PersonalityRoleField]] = {
109       implicit val context: EC = readExecutionContext
110       Future(NamedDB("READ").retryableTx { implicit session =>
111         withSQL {
112           val query: scalikejdbc.PagingSQLBuilder[PersistentPersonalityRoleField] = select
113             .from(PersistentPersonalityRoleField.as(personalityRoleFieldAlias))
114             .where(
115               sqls.toAndConditionOpt(
116                 maybePersonalityRoleId.map(
117                   personalityRoleId => sqls.eq(personalityRoleFieldAlias.personalityRoleId, personalityRoleId.value)
118                 ),
119                 maybeName.map(name           => sqls.eq(personalityRoleFieldAlias.name, name)),
120                 maybeFieldType.map(fieldType => sqls.eq(personalityRoleFieldAlias.fieldType, fieldType)),
121                 maybeRequired.map(required   => sqls.eq(personalityRoleFieldAlias.required, required))
122               )
123             )
124           sortOrderQuery(offset = offset, end = end, sort = sort, order = order, query = query)
125         }.map(PersistentPersonalityRoleField.apply()).list()
126       }).map(_.map(_.toPersonalityRoleField))
127     }
128 
129     def count(
130       maybePersonalityRoleId: Option[PersonalityRoleId],
131       maybeName: Option[String],
132       maybeFieldType: Option[FieldType],
133       maybeRequired: Option[Boolean]
134     ): Future[Int] = {
135       implicit val context: EC = readExecutionContext
136       Future(NamedDB("READ").retryableTx { implicit session =>
137         withSQL {
138           select(sqls.count)
139             .from(PersistentPersonalityRoleField.as(personalityRoleFieldAlias))
140             .where(
141               sqls.toAndConditionOpt(
142                 maybePersonalityRoleId.map(
143                   personalityRoleId => sqls.eq(personalityRoleFieldAlias.personalityRoleId, personalityRoleId.value)
144                 ),
145                 maybeName.map(name           => sqls.eq(personalityRoleFieldAlias.name, name)),
146                 maybeFieldType.map(fieldType => sqls.eq(personalityRoleFieldAlias.fieldType, fieldType)),
147                 maybeRequired.map(required   => sqls.eq(personalityRoleFieldAlias.required, required))
148               )
149             )
150         }.map(_.int(1)).single().getOrElse(0)
151       })
152     }
153 
154     override def delete(personalityRoleFieldId: PersonalityRoleFieldId): Future[Unit] = {
155       implicit val context: EC = readExecutionContext
156       Future(NamedDB("WRITE").retryableTx { implicit session =>
157         withSQL {
158           deleteFrom(PersistentPersonalityRoleField)
159             .where(sqls.eq(column.id, personalityRoleFieldId.value))
160         }.execute()
161       }).void
162     }
163 
164   }
165 }
166 
167 object DefaultPersistentPersonalityRoleFieldServiceComponent {
168 
169   final case class PersistentPersonalityRoleField(
170     id: String,
171     personalityRoleId: String,
172     name: String,
173     fieldType: String,
174     required: Boolean
175   ) {
176     def toPersonalityRoleField: PersonalityRoleField = {
177       PersonalityRoleField(
178         personalityRoleFieldId = PersonalityRoleFieldId(id),
179         personalityRoleId = PersonalityRoleId(personalityRoleId),
180         name = name,
181         fieldType = FieldType.withValue(fieldType),
182         required = required
183       )
184     }
185   }
186 
187   implicit object PersistentPersonalityRoleField
188       extends PersistentCompanion[PersistentPersonalityRoleField, PersonalityRoleField] {
189     override val columnNames: Seq[String] =
190       Seq("id", "personality_role_id", "name", "field_type", "required")
191     final val swaggerAllowableValues = "id,personality_role_id,name,field_type,required"
192 
193     override val tableName: String = "personality_role_field"
194 
195     override lazy val alias: SyntaxProvider[PersistentPersonalityRoleField] = syntax("personality_role_field")
196 
197     override lazy val defaultSortColumns: NonEmptyList[SQLSyntax] = NonEmptyList.of(alias.name)
198 
199     def apply(
200       personalityResultName: ResultName[PersistentPersonalityRoleField] = alias.resultName
201     )(resultSet: WrappedResultSet): PersistentPersonalityRoleField = {
202       PersistentPersonalityRoleField.apply(
203         id = resultSet.string(personalityResultName.id),
204         personalityRoleId = resultSet.string(personalityResultName.personalityRoleId),
205         name = resultSet.string(personalityResultName.name),
206         fieldType = resultSet.string(personalityResultName.fieldType),
207         required = resultSet.boolean(personalityResultName.required)
208       )
209     }
210   }
211 
212 }