1 /*
2  *  Make.org Core API
3  *  Copyright (C) 2018-2019 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.implicits._
23 import akka.http.scaladsl.model.StatusCodes
24 import akka.http.scaladsl.server._
25 import io.circe.Codec
26 import io.circe.generic.semiauto.deriveCodec
27 import io.swagger.annotations._
28 import org.make.api.operation.OperationServiceComponent
29 import org.make.core.reference.Language
30 import org.make.api.question.QuestionServiceComponent
31 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
32 import org.make.api.technical.{`X-Total-Count`, IdResponse, MakeAuthenticationDirectives}
33 import org.make.api.technical.directives.FutureDirectivesExtensions._
34 import org.make.core.auth.UserRights
35 import org.make.core.crmTemplate.{CrmQuestionTemplate, CrmQuestionTemplateId, CrmTemplateKind, TemplateId}
36 import org.make.core.question.QuestionId
37 import org.make.core.{HttpCodes, ParameterExtractors, Validation, ValidationError}
38 import scalaoauth2.provider.AuthInfo
39 
40 import javax.ws.rs.Path
41 import scala.annotation.meta.field
42 
43 @Api(value = "Admin Crm Templates - Questions")
44 @Path(value = "/admin/crm-templates/questions")
45 trait AdminCrmQuestionTemplatesApi extends Directives {
46 
47   @ApiOperation(
48     value = "list-crm-question-templates",
49     httpMethod = "GET",
50     code = HttpCodes.OK,
51     authorizations = Array(
52       new Authorization(
53         value = "MakeApi",
54         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
55       )
56     )
57   )
58   @ApiImplicitParams(
59     value = Array(new ApiImplicitParam(name = "questionId", paramType = "query", dataType = "string", required = true))
60   )
61   @ApiResponses(
62     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[CrmQuestionTemplate]]))
63   )
64   @Path(value = "/")
65   def adminListCrmQuestionTemplates: Route
66 
67   @ApiOperation(
68     value = "create-crm-question-template",
69     httpMethod = "POST",
70     code = HttpCodes.OK,
71     authorizations = Array(
72       new Authorization(
73         value = "MakeApi",
74         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
75       )
76     )
77   )
78   @ApiImplicitParams(
79     value = Array(
80       new ApiImplicitParam(
81         value = "body",
82         paramType = "body",
83         dataType = "org.make.api.crmTemplates.CreateCrmQuestionTemplate"
84       )
85     )
86   )
87   @ApiResponses(
88     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[CrmQuestionTemplate]))
89   )
90   @Path(value = "/")
91   def adminCreateCrmQuestionTemplates: Route
92 
93   @Path(value = "/{crmQuestionTemplateId}")
94   @ApiOperation(
95     value = "get-crm-question-template",
96     httpMethod = "GET",
97     code = HttpCodes.OK,
98     authorizations = Array(
99       new Authorization(
100         value = "MakeApi",
101         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
102       )
103     )
104   )
105   @ApiResponses(
106     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[CrmQuestionTemplate]))
107   )
108   @ApiImplicitParams(
109     value = Array(new ApiImplicitParam(name = "crmQuestionTemplateId", paramType = "path", dataType = "string"))
110   )
111   def adminGetCrmQuestionTemplates: Route
112 
113   @ApiOperation(
114     value = "update-crm-question-template",
115     httpMethod = "PUT",
116     code = HttpCodes.OK,
117     authorizations = Array(
118       new Authorization(
119         value = "MakeApi",
120         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
121       )
122     )
123   )
124   @ApiImplicitParams(
125     value = Array(
126       new ApiImplicitParam(name = "crmQuestionTemplateId", paramType = "path", dataType = "string"),
127       new ApiImplicitParam(
128         value = "body",
129         paramType = "body",
130         dataType = "org.make.core.crmTemplate.CrmQuestionTemplate"
131       )
132     )
133   )
134   @ApiResponses(
135     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[CrmQuestionTemplate]))
136   )
137   @Path(value = "/{crmQuestionTemplateId}")
138   def adminUpdateCrmQuestionTemplates: Route
139 
140   @ApiOperation(
141     value = "delete-crm-question-template",
142     httpMethod = "DELETE",
143     code = HttpCodes.OK,
144     authorizations = Array(
145       new Authorization(
146         value = "MakeApi",
147         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
148       )
149     )
150   )
151   @ApiImplicitParams(
152     value = Array(new ApiImplicitParam(name = "crmQuestionTemplateId", paramType = "path", dataType = "string"))
153   )
154   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[IdResponse])))
155   @Path(value = "/{crmQuestionTemplateId}")
156   def adminDeleteCrmQuestionTemplates: Route
157 
158   def routes: Route =
159     adminListCrmQuestionTemplates ~ adminCreateCrmQuestionTemplates ~ adminGetCrmQuestionTemplates ~ adminUpdateCrmQuestionTemplates ~ adminDeleteCrmQuestionTemplates
160 }
161 
162 trait AdminCrmQuestionTemplatesApiComponent {
163   def adminCrmQuestionTemplatesApi: AdminCrmQuestionTemplatesApi
164 }
165 
166 trait DefaultAdminCrmQuestionTemplatesApiComponent
167     extends AdminCrmQuestionTemplatesApiComponent
168     with MakeAuthenticationDirectives
169     with ParameterExtractors {
170   this: MakeDirectivesDependencies
171     with CrmTemplatesServiceComponent
172     with QuestionServiceComponent
173     with OperationServiceComponent =>
174 
175   val crmQuestionTemplateId: PathMatcher1[CrmQuestionTemplateId] = Segment.map(CrmQuestionTemplateId.apply)
176 
177   override lazy val adminCrmQuestionTemplatesApi: AdminCrmQuestionTemplatesApi = new DefaultAdminCrmQuestionTemplatesApi
178 
179   class DefaultAdminCrmQuestionTemplatesApi extends AdminCrmQuestionTemplatesApi {
180 
181     override def adminListCrmQuestionTemplates: Route = {
182       get {
183         path("admin" / "crm-templates" / "questions") {
184           makeOperation("AdminListCrmQuestionTemplates") { _ =>
185             parameters("questionId".as[QuestionId]) { (questionId: QuestionId) =>
186               makeOAuth2 { userAuth: AuthInfo[UserRights] =>
187                 requireAdminRole(userAuth.user) {
188                   crmTemplatesService.list(questionId).asDirective { templates =>
189                     complete((StatusCodes.OK, List(`X-Total-Count`(templates.size.toString)), templates))
190                   }
191                 }
192               }
193             }
194           }
195         }
196       }
197     }
198 
199     override def adminCreateCrmQuestionTemplates: Route = post {
200       path("admin" / "crm-templates" / "questions") {
201         makeOperation("AdminCreateCrmQuestionTemplates") { _ =>
202           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
203             requireAdminRole(userAuth.user) {
204               decodeRequest {
205                 entity(as[CreateCrmQuestionTemplate]) { request: CreateCrmQuestionTemplate =>
206                   (
207                     questionService
208                       .getCachedQuestion(request.questionId)
209                       .asDirectiveOrBadRequest(
210                         ValidationError(
211                           "questionId",
212                           "not_found",
213                           Some(s"Question ${request.questionId} does not exist.")
214                         )
215                       ),
216                     crmTemplatesService.list(request.questionId).asDirective
217                   ).mapN({
218                       case (_, allQuestionTemplates: Seq[CrmQuestionTemplate]) =>
219                         Validation.validate(
220                           Validation.validateField(
221                             field = "templateKind",
222                             key = "invalid_value",
223                             condition = !allQuestionTemplates.exists(
224                               templates => templates.kind == request.kind && templates.language == request.language
225                             ),
226                             message = "This CRM template kind already exist for this question and language."
227                           )
228                         )
229                         crmTemplatesService
230                           .create(request.toCrmQuestionTemplate(idGenerator.nextCrmQuestionTemplateId()))
231                           .asDirective
232                     })
233                     .flatten
234                     .apply(template => complete(StatusCodes.Created -> template))
235                 }
236               }
237             }
238           }
239         }
240       }
241     }
242 
243     override def adminGetCrmQuestionTemplates: Route = {
244       get {
245         path("admin" / "crm-templates" / "questions" / crmQuestionTemplateId) { crmQuestionTemplateId =>
246           makeOperation("AdminGetCrmQuestionTemplates") { _ =>
247             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
248               requireAdminRole(userAuth.user) {
249                 crmTemplatesService
250                   .get(crmQuestionTemplateId)
251                   .asDirectiveOrNotFound
252                   .apply(complete(_))
253               }
254             }
255           }
256         }
257       }
258     }
259 
260     override def adminUpdateCrmQuestionTemplates: Route = put {
261       path("admin" / "crm-templates" / "questions" / crmQuestionTemplateId) { crmQuestionTemplateId =>
262         makeOperation("AdminUpdateCrmQuestionTemplates") { _ =>
263           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
264             requireAdminRole(userAuth.user) {
265               decodeRequest {
266                 entity(as[CrmQuestionTemplate]) { request: CrmQuestionTemplate =>
267                   val templateDirective =
268                     for {
269                       _ <- crmTemplatesService.get(crmQuestionTemplateId).asDirectiveOrNotFound
270                       _ <- questionService
271                         .getCachedQuestion(request.questionId)
272                         .asDirectiveOrBadRequest(
273                           ValidationError(
274                             "questionId",
275                             "not_found",
276                             Some(s"Question ${request.questionId} does not exist.")
277                           )
278                         )
279                       template <- crmTemplatesService.update(request).asDirective
280                     } yield template
281                   templateDirective(complete(_))
282                 }
283               }
284             }
285           }
286         }
287       }
288     }
289 
290     override def adminDeleteCrmQuestionTemplates: Route = {
291       delete {
292         path("admin" / "crm-templates" / "questions" / crmQuestionTemplateId) { crmQuestionTemplateId =>
293           makeOperation("AdminGetCrmQuestionTemplates") { _ =>
294             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
295               requireAdminRole(userAuth.user) {
296                 crmTemplatesService.delete(crmQuestionTemplateId).asDirective { _ =>
297                   complete(IdResponse(crmQuestionTemplateId))
298                 }
299               }
300             }
301           }
302         }
303       }
304     }
305   }
306 }
307 
308 final case class CreateCrmQuestionTemplate(
309   @(ApiModelProperty @field)(
310     dataType = "string",
311     required = true,
312     allowableValues = CrmTemplateKind.swaggerAllowableValues
313   )
314   kind: CrmTemplateKind,
315   @(ApiModelProperty @field)(dataType = "string", required = true, example = "11111111-2222-3333-4444-555555555555")
316   questionId: QuestionId,
317   @(ApiModelProperty @field)(dataType = "string", required = true, example = "123456")
318   template: TemplateId,
319   @(ApiModelProperty @field)(dataType = "string", required = true, example = "fr")
320   language: Language
321 ) {
322   def toCrmQuestionTemplate(id: CrmQuestionTemplateId): CrmQuestionTemplate =
323     CrmQuestionTemplate(id = id, kind = kind, questionId = questionId, template = template, language = language)
324 }
325 
326 object CreateCrmQuestionTemplate {
327 
328   implicit val codec: Codec[CreateCrmQuestionTemplate] = deriveCodec
329 }