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.DefaultPersistentPersonalityRoleServiceComponent.PersistentPersonalityRole
26 import org.make.api.technical.DatabaseTransactions._
27 import org.make.api.technical.PersistentServiceUtils.sortOrderQuery
28 import org.make.api.technical.{PersistentCompanion, ShortenedNames}
29 import org.make.core.technical.Pagination
30 import org.make.core.personality.{PersonalityRole, PersonalityRoleId}
31 import org.make.core.Order
32 import scalikejdbc._
33 
34 import scala.concurrent.Future
35 
36 trait DefaultPersistentPersonalityRoleServiceComponent extends PersistentPersonalityRoleServiceComponent {
37   this: MakeDBExecutionContextComponent =>
38 
39   override lazy val persistentPersonalityRoleService: DefaultPersistentPersonalityRoleService =
40     new DefaultPersistentPersonalityRoleService
41 
42   class DefaultPersistentPersonalityRoleService extends PersistentPersonalityRoleService with ShortenedNames {
43 
44     private val personalityRoleAlias = PersistentPersonalityRole.alias
45 
46     private val column = PersistentPersonalityRole.column
47 
48     override def persist(personalityRole: PersonalityRole): Future[PersonalityRole] = {
49       implicit val context: EC = writeExecutionContext
50       Future(NamedDB("WRITE").retryableTx { implicit session =>
51         withSQL {
52           insert
53             .into(PersistentPersonalityRole)
54             .namedValues(column.id -> personalityRole.personalityRoleId.value, column.name -> personalityRole.name)
55         }.execute()
56       }).as(personalityRole)
57     }
58 
59     override def modify(personalityRole: PersonalityRole): Future[PersonalityRole] = {
60       implicit val context: EC = writeExecutionContext
61       Future(NamedDB("WRITE").retryableTx { implicit session =>
62         withSQL {
63           update(PersistentPersonalityRole)
64             .set(column.name -> personalityRole.name)
65             .where(sqls.eq(column.id, personalityRole.personalityRoleId.value))
66         }.execute()
67       }).as(personalityRole)
68     }
69 
70     override def getById(personalityRoleId: PersonalityRoleId): Future[Option[PersonalityRole]] = {
71       implicit val context: EC = readExecutionContext
72       Future(NamedDB("READ").retryableTx { implicit session =>
73         withSQL {
74           select
75             .from(PersistentPersonalityRole.as(personalityRoleAlias))
76             .where(sqls.eq(personalityRoleAlias.id, personalityRoleId.value))
77         }.map(PersistentPersonalityRole.apply()).single()
78       }).map(_.map(_.toPersonalityRole))
79     }
80 
81     override def find(
82       offset: Pagination.Offset,
83       end: Option[Pagination.End],
84       sort: Option[String],
85       order: Option[Order],
86       maybeRoleIds: Option[Seq[PersonalityRoleId]],
87       maybeName: Option[String]
88     ): Future[Seq[PersonalityRole]] = {
89       implicit val context: EC = readExecutionContext
90       Future(NamedDB("READ").retryableTx { implicit session =>
91         withSQL {
92           val query: scalikejdbc.PagingSQLBuilder[PersistentPersonalityRole] = select
93             .from(PersistentPersonalityRole.as(personalityRoleAlias))
94             .where(
95               sqls.toAndConditionOpt(
96                 maybeName.map(name       => sqls.eq(personalityRoleAlias.name, name)),
97                 maybeRoleIds.map(roleIds => sqls.in(personalityRoleAlias.id, roleIds.map(_.value)))
98               )
99             )
100           sortOrderQuery(offset, end, sort, order, query)
101         }.map(PersistentPersonalityRole.apply()).list()
102       }).map(_.map(_.toPersonalityRole))
103     }
104 
105     override def count(maybeRoleIds: Option[Seq[PersonalityRoleId]], maybeName: Option[String]): Future[Int] = {
106       implicit val context: EC = readExecutionContext
107       Future(NamedDB("READ").retryableTx { implicit session =>
108         withSQL {
109           select(sqls.count)
110             .from(PersistentPersonalityRole.as(personalityRoleAlias))
111             .where(
112               sqls.toAndConditionOpt(
113                 maybeName.map(name       => sqls.eq(personalityRoleAlias.name, name)),
114                 maybeRoleIds.map(roleIds => sqls.in(personalityRoleAlias.id, roleIds.map(_.value)))
115               )
116             )
117         }.map(_.int(1)).single().getOrElse(0)
118       })
119     }
120 
121     override def delete(personalityRoleId: PersonalityRoleId): Future[Unit] = {
122       implicit val context: EC = readExecutionContext
123       Future(NamedDB("WRITE").retryableTx { implicit session =>
124         withSQL {
125           deleteFrom(PersistentPersonalityRole)
126             .where(sqls.eq(column.id, personalityRoleId.value))
127         }.execute()
128       }).void
129     }
130 
131   }
132 }
133 
134 object DefaultPersistentPersonalityRoleServiceComponent {
135 
136   final case class PersistentPersonalityRole(id: String, name: String) {
137     def toPersonalityRole: PersonalityRole = {
138       PersonalityRole(personalityRoleId = PersonalityRoleId(id), name = name)
139     }
140   }
141 
142   implicit object PersistentPersonalityRole extends PersistentCompanion[PersistentPersonalityRole, PersonalityRole] {
143     override val columnNames: Seq[String] =
144       Seq("id", "name")
145     final val swaggerAllowableValues = "id,name"
146 
147     override val tableName: String = "personality_role"
148 
149     override lazy val alias: SyntaxProvider[PersistentPersonalityRole] = syntax("personality_role")
150 
151     override lazy val defaultSortColumns: NonEmptyList[SQLSyntax] = NonEmptyList.of(alias.name)
152 
153     def apply(
154       personalityResultName: ResultName[PersistentPersonalityRole] = alias.resultName
155     )(resultSet: WrappedResultSet): PersistentPersonalityRole = {
156       PersistentPersonalityRole.apply(
157         id = resultSet.string(personalityResultName.id),
158         name = resultSet.string(personalityResultName.name)
159       )
160     }
161   }
162 
163 }