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.crmTemplates
21 
22 import cats.instances.future._
23 import cats.instances.option._
24 import cats.syntax.traverse._
25 import grizzled.slf4j.Logging
26 import org.make.api.technical._
27 import org.make.api.technical.Futures._
28 import org.make.core.crmTemplate.{
29   CrmLanguageTemplate,
30   CrmLanguageTemplateId,
31   CrmQuestionTemplate,
32   CrmQuestionTemplateId,
33   CrmTemplate,
34   CrmTemplateKind,
35   TemplateId
36 }
37 import org.make.core.question.QuestionId
38 
39 import scala.concurrent.ExecutionContext.Implicits.global
40 import scala.concurrent.Future
41 import org.make.core.reference.Language
42 
43 import scala.collection.SortedMap
44 import scala.util.{Failure, Success, Try}
45 
46 trait DefaultCrmTemplatesServiceComponent extends CrmTemplatesServiceComponent {
47   this: PersistentCrmLanguageTemplateServiceComponent
48     with PersistentCrmQuestionTemplateServiceComponent
49     with IdGeneratorComponent =>
50 
51   override lazy val crmTemplatesService: CrmTemplatesService = new DefaultCrmTemplatesService
52 
53   class DefaultCrmTemplatesService extends CrmTemplatesService with Logging {
54 
55     override def find(
56       kind: CrmTemplateKind,
57       questionId: Option[QuestionId],
58       language: Option[Language]
59     ): Future[Option[TemplateId]] = {
60 
61       val byQuestion: () => Future[Option[Option[CrmTemplate]]] = () =>
62         questionId.traverse(id => listByLanguage(id, language).map(_.find(_.kind == kind)))
63       val byLanguage = () => language.traverse(get(_).map(_.map(_(kind))))
64       val default = ()    => get(Language("en")).map(_.map(_(kind)))
65 
66       val result = byQuestion.or(byLanguage.or(default)).apply().map(_.map(_.template))
67 
68       result.foreach(
69         r =>
70           if (r.isEmpty)
71             logger.error(s"No $kind template found for question: $questionId and language $language.")
72       )
73 
74       result
75     }
76 
77     // Language templates
78 
79     override def listByLanguage(): Future[SortedMap[Language, CrmTemplateKind => CrmLanguageTemplate]] = {
80       persistentCrmLanguageTemplateService
81         .all()
82         .map(
83           all =>
84             SortedMap.from(
85               all
86                 .groupBy(_.language)
87                 .map {
88                   case (language, templates) =>
89                     val validated = validate(language, templates)
90                     validated.failed.foreach(logger.error("Listing an invalid language in CRM language templates", _))
91                     language -> validated
92                 }
93                 .collect { case (language, Success(templates)) => language -> templates }
94             )
95         )
96     }
97 
98     override def get(language: Language): Future[Option[CrmTemplateKind => CrmLanguageTemplate]] = {
99       persistentCrmLanguageTemplateService.list(language).flatMap { raw =>
100         if (raw.isEmpty) {
101           Future.successful(None)
102         } else {
103           Future.fromTry(validate(language, raw)).map(Some.apply)
104         }
105       }
106     }
107 
108     override def create(
109       language: Language,
110       values: CrmTemplateKind => TemplateId
111     ): Future[CrmTemplateKind => CrmLanguageTemplate] = {
112       val templates = CrmTemplateKind.values.map(
113         kind => CrmLanguageTemplate(CrmLanguageTemplateId(idGenerator.nextId()), kind, language, values(kind))
114       )
115       persistentCrmLanguageTemplateService
116         .persist(templates)
117         .flatMap(result => Future.fromTry(validate(language, result)))
118     }
119 
120     override def update(
121       language: Language,
122       values: CrmTemplateKind => TemplateId
123     ): Future[CrmTemplateKind => CrmLanguageTemplate] = {
124       persistentCrmLanguageTemplateService
125         .list(language)
126         .flatMap(
127           current =>
128             validate(language, current) match {
129               case Success(_) =>
130                 persistentCrmLanguageTemplateService
131                   .modify(current.map(template => template.copy(template = values(template.kind))))
132                   .flatMap(result => Future.fromTry(validate(language, result)))
133               case Failure(e) => Future.failed(e)
134             }
135         )
136     }
137 
138     private def validate(
139       language: Language,
140       templates: Seq[CrmLanguageTemplate]
141     ): Try[CrmTemplateKind => CrmLanguageTemplate] = {
142       val indexed = templates.groupMapReduce(_.kind)(identity)((template, _) => template)
143       val missing = CrmTemplateKind.values.toSet -- indexed.keys
144       if (missing.isEmpty) {
145         Success(indexed.apply)
146       } else {
147         Failure(
148           new IllegalStateException(s"Missing CRM language templates for ${language.value}: ${missing.mkString(", ")}")
149         )
150       }
151     }
152 
153     // Question templates
154 
155     override def list(questionId: QuestionId): Future[Seq[CrmQuestionTemplate]] = {
156       persistentCrmQuestionTemplateService.list(questionId)
157     }
158 
159     override def listByLanguage(
160       questionId: QuestionId,
161       language: Option[Language]
162     ): Future[Seq[CrmQuestionTemplate]] = {
163       language match {
164         case None           => Future.successful(Seq.empty)
165         case Some(language) => persistentCrmQuestionTemplateService.listByLanguage(questionId, language)
166       }
167     }
168 
169     override def get(id: CrmQuestionTemplateId): Future[Option[CrmQuestionTemplate]] = {
170       persistentCrmQuestionTemplateService.get(id)
171     }
172 
173     override def create(template: CrmQuestionTemplate): Future[CrmQuestionTemplate] = {
174       persistentCrmQuestionTemplateService.persist(template)
175     }
176 
177     override def update(template: CrmQuestionTemplate): Future[CrmQuestionTemplate] = {
178       persistentCrmQuestionTemplateService.modify(template)
179     }
180 
181     override def delete(id: CrmQuestionTemplateId): Future[Unit] = {
182       persistentCrmQuestionTemplateService.remove(id)
183     }
184   }
185 }