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