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.crmTemplates
21 
22 import org.make.api.extensions.MakeDBExecutionContextComponent
23 import org.make.api.technical.ShortenedNames
24 import org.make.api.technical.DatabaseTransactions._
25 import org.make.api.technical.ScalikeSupport._
26 import org.make.core.crmTemplate.{CrmQuestionTemplate, CrmQuestionTemplateId}
27 import org.make.core.question.QuestionId
28 import org.make.core.reference.Language
29 import scalikejdbc._
30 
31 import scala.concurrent.Future
32 
33 trait DefaultPersistentCrmQuestionTemplateServiceComponent extends PersistentCrmQuestionTemplateServiceComponent {
34   this: MakeDBExecutionContextComponent =>
35 
36   override lazy val persistentCrmQuestionTemplateService: PersistentCrmQuestionTemplateService =
37     new DefaultPersistentCrmQuestionTemplateService
38 
39   class DefaultPersistentCrmQuestionTemplateService extends PersistentCrmQuestionTemplateService with ShortenedNames {
40 
41     private val templates = SQLSyntaxSupportFactory[CrmQuestionTemplate]()
42     private val t = templates.syntax
43 
44     override def list(questionId: QuestionId): Future[Seq[CrmQuestionTemplate]] = {
45       implicit val context: EC = readExecutionContext
46       Future(NamedDB("READ").retryableTx { implicit session =>
47         withSQL { select.from(templates.as(t)).where.eq(t.questionId, questionId) }
48           .map(templates.apply(t.resultName))
49           .list()
50       })
51     }
52 
53     override def listByLanguage(questionId: QuestionId, language: Language): Future[Seq[CrmQuestionTemplate]] = {
54       implicit val context: EC = readExecutionContext
55       Future(NamedDB("READ").retryableTx { implicit session =>
56         withSQL {
57           select
58             .from(templates.as(t))
59             .where
60             .eq(t.questionId, questionId)
61             .and
62             .eq(t.language, language)
63         }.map(templates.apply(t.resultName))
64           .list()
65       })
66     }
67 
68     override def get(id: CrmQuestionTemplateId): Future[Option[CrmQuestionTemplate]] = {
69       implicit val context: EC = readExecutionContext
70       Future(NamedDB("READ").retryableTx { implicit session =>
71         withSQL { select.from(templates.as(t)).where.eq(t.id, id) }
72           .map(templates.apply(t.resultName))
73           .single()
74       })
75     }
76 
77     override def persist(template: CrmQuestionTemplate): Future[CrmQuestionTemplate] = {
78       implicit val context: EC = writeExecutionContext
79       Future(NamedDB("WRITE").retryableTx { implicit session =>
80         withSQL { insert.into(templates).namedValues(autoNamedValues(template, templates.column)) }.update()
81       }).map(_ => template)
82     }
83 
84     override def modify(template: CrmQuestionTemplate): Future[CrmQuestionTemplate] = {
85       implicit val context: EC = writeExecutionContext
86       Future(NamedDB("WRITE").retryableTx { implicit session =>
87         withSQL {
88           update(templates).set(autoNamedValues(template, templates.column, "id")).where.eq(t.id, template.id)
89         }.update()
90       }).map(_ => template)
91     }
92 
93     override def remove(id: CrmQuestionTemplateId): Future[Unit] = {
94       implicit val context: EC = readExecutionContext
95       Future(NamedDB("WRITE").retryableTx { implicit session =>
96         withSQL { delete.from(templates).where.eq(t.id, id) }.execute()
97       })
98     }
99   }
100 
101 }