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.tag
21 
22 import org.make.api.proposal.ProposalSearchEngineComponent
23 import org.make.api.proposal.PublishedProposalEvent.ReindexProposal
24 import org.make.api.tagtype.{PersistentTagTypeServiceComponent, TagTypeServiceComponent}
25 import org.make.api.technical._
26 import org.make.core.technical.Pagination
27 import org.make.core.proposal._
28 import org.make.core.proposal.indexed.IndexedTag
29 import org.make.core.question.{Question, QuestionId}
30 import org.make.core.tag._
31 import org.make.core.{DateHelper, Order, RequestContext}
32 
33 import scala.concurrent.ExecutionContext.Implicits.global
34 import scala.concurrent.Future
35 
36 trait DefaultTagServiceComponent
37     extends TagServiceComponent
38     with ShortenedNames
39     with ProposalSearchEngineComponent
40     with TagTypeServiceComponent
41     with PersistentTagTypeServiceComponent {
42   this: PersistentTagServiceComponent with EventBusServiceComponent with IdGeneratorComponent =>
43 
44   override lazy val tagService: TagService = new DefaultTagService
45 
46   class DefaultTagService extends TagService {
47 
48     override def getTag(tagId: TagId): Future[Option[Tag]] = {
49       persistentTagService.get(tagId)
50     }
51 
52     override def findAll(): Future[Seq[Tag]] = {
53       persistentTagService.findAll()
54     }
55 
56     override def findAllDisplayed(): Future[Seq[Tag]] = {
57       persistentTagService.findAllDisplayed()
58     }
59 
60     override def findByTagIds(tagIds: Seq[TagId]): Future[Seq[Tag]] = {
61       persistentTagService.findAllFromIds(tagIds)
62     }
63 
64     override def findByQuestionId(questionId: QuestionId): Future[Seq[Tag]] = {
65       persistentTagService.findByQuestion(questionId)
66     }
67 
68     override def createTag(
69       label: String,
70       tagTypeId: TagTypeId,
71       question: Question,
72       display: TagDisplay,
73       weight: Float
74     ): Future[Tag] = {
75       val tag: Tag = Tag(
76         tagId = idGenerator.nextTagId(),
77         label = label,
78         display = display,
79         weight = weight,
80         tagTypeId = tagTypeId,
81         operationId = question.operationId,
82         questionId = Some(question.questionId)
83       )
84       persistentTagService.persist(tag)
85     }
86 
87     override def retrieveIndexedTags(tags: Seq[Tag], tagTypes: Seq[TagType]): Seq[IndexedTag] = {
88       tags.map { tag =>
89         if (tag.display == TagDisplay.Inherit) {
90           val tagType: Seq[TagType] = tagTypes.filter(tagType => tagType.tagTypeId == tag.tagTypeId)
91           IndexedTag(
92             tagId = tag.tagId,
93             label = tag.label,
94             display = tagType.nonEmpty && tagType.headOption
95               .map(_.display.value)
96               .contains(TagDisplay.Displayed.value)
97           )
98         } else {
99           IndexedTag(tagId = tag.tagId, label = tag.label, display = tag.display == TagDisplay.Displayed)
100         }
101       }
102     }
103 
104     override def findByLabel(partialLabel: String, like: Boolean): Future[Seq[Tag]] = {
105       if (partialLabel.isEmpty) {
106         persistentTagService.findAll()
107       } else if (like) {
108         persistentTagService.findByLabelLike(partialLabel)
109       } else {
110         persistentTagService.findByLabel(partialLabel)
111       }
112     }
113 
114     override def updateTag(
115       tagId: TagId,
116       label: String,
117       display: TagDisplay,
118       tagTypeId: TagTypeId,
119       weight: Float,
120       question: Question,
121       requestContext: RequestContext
122     ): Future[Option[Tag]] = {
123       persistentTagService.get(tagId).flatMap {
124         case Some(tag) =>
125           for {
126             tagType <- tagTypeService.getTagType(tagTypeId)
127             updateTag <- persistentTagService.update(
128               tag.copy(
129                 label = label,
130                 display = display,
131                 tagTypeId = tagTypeId,
132                 weight = weight,
133                 operationId = question.operationId,
134                 questionId = Some(question.questionId)
135               )
136             )
137             _ <- elasticsearchProposalAPI
138               .searchProposals(SearchQuery(filters = Some(SearchFilters(tags = Some(TagsSearchFilter(Seq(tagId)))))))
139               .map(_.results.foreach { proposal =>
140                 eventBusService.publish(
141                   ReindexProposal(proposal.id, DateHelper.now(), requestContext, Some(idGenerator.nextEventId()))
142                 )
143               })
144           } yield updateTag
145         case None => Future.successful(None)
146       }
147     }
148 
149     override def find(
150       offset: Pagination.Offset = Pagination.Offset.zero,
151       end: Option[Pagination.End] = None,
152       sort: Option[String] = None,
153       order: Option[Order] = None,
154       onlyDisplayed: Boolean = false,
155       tagFilter: TagFilter
156     ): Future[Seq[Tag]] = {
157 
158       persistentTagService.find(
159         offset,
160         end,
161         sort,
162         order,
163         onlyDisplayed,
164         PersistentTagFilter(tagFilter.tagIds, tagFilter.label, tagFilter.questionIds, tagFilter.tagTypeId)
165       )
166 
167     }
168 
169     override def count(tagFilter: TagFilter = TagFilter.empty): Future[Int] = {
170       persistentTagService.count(
171         PersistentTagFilter(tagFilter.tagIds, tagFilter.label, tagFilter.questionIds, tagFilter.tagTypeId)
172       )
173     }
174   }
175 }