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.generic.semiauto.deriveCodec
26 import io.circe.Codec
27 import io.swagger.annotations._
28 import org.make.api.operation.OperationServiceComponent
29 import org.make.api.question.QuestionServiceComponent
30 import org.make.api.technical.{`X-Total-Count`, MakeAuthenticationDirectives}
31 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
32 import org.make.api.technical.directives.FutureDirectivesExtensions._
33 import org.make.core.technical.ValidatedUtils.ValidatedNecWithUtils
34 import org.make.core.auth.UserRights
35 import org.make.core.crmTemplate.{CrmLanguageTemplate, CrmTemplateKind, TemplateId}
36 import org.make.core.reference.Language
37 import org.make.core.{BusinessConfig, HttpCodes}
38 import org.make.core.Validation.AnyWithParsers
39 import scalaoauth2.provider.AuthInfo
40 
41 import javax.ws.rs.Path
42 import scala.annotation.meta.field
43 import scala.util.Try
44 
45 @Api(value = "Admin Crm Templates - Languages")
46 @Path(value = "/admin/crm-templates/languages")
47 trait AdminCrmLanguageTemplatesApi extends Directives {
48 
49   @ApiOperation(
50     value = "list-crm-templates-languages",
51     httpMethod = "GET",
52     code = HttpCodes.OK,
53     authorizations = Array(
54       new Authorization(
55         value = "MakeApi",
56         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
57       )
58     )
59   )
60   @ApiResponses(
61     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[CrmLanguageTemplates]]))
62   )
63   @Path(value = "/")
64   def adminListCrmLanguageTemplates: Route
65 
66   @ApiOperation(
67     value = "create-crm-templates-language",
68     httpMethod = "POST",
69     code = HttpCodes.OK,
70     authorizations = Array(
71       new Authorization(
72         value = "MakeApi",
73         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
74       )
75     )
76   )
77   @ApiImplicitParams(
78     value = Array(
79       new ApiImplicitParam(
80         value = "body",
81         paramType = "body",
82         dataType = "org.make.api.crmTemplates.CrmLanguageTemplates"
83       )
84     )
85   )
86   @ApiResponses(
87     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[CrmLanguageTemplates]))
88   )
89   @Path(value = "/")
90   def adminCreateCrmLanguageTemplates: Route
91 
92   @Path(value = "/{language}")
93   @ApiOperation(
94     value = "get-crm-templates-language",
95     httpMethod = "GET",
96     code = HttpCodes.OK,
97     authorizations = Array(
98       new Authorization(
99         value = "MakeApi",
100         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
101       )
102     )
103   )
104   @ApiResponses(
105     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[CrmLanguageTemplates]))
106   )
107   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "language", paramType = "path", dataType = "string")))
108   def adminGetCrmLanguageTemplates: Route
109 
110   @ApiOperation(
111     value = "update-crm-templates-language",
112     httpMethod = "PUT",
113     code = HttpCodes.OK,
114     authorizations = Array(
115       new Authorization(
116         value = "MakeApi",
117         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
118       )
119     )
120   )
121   @ApiImplicitParams(
122     value = Array(
123       new ApiImplicitParam(name = "language", paramType = "path", dataType = "string"),
124       new ApiImplicitParam(
125         value = "body",
126         paramType = "body",
127         dataType = "org.make.api.crmTemplates.CrmLanguageTemplates"
128       )
129     )
130   )
131   @ApiResponses(
132     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[CrmLanguageTemplates]))
133   )
134   @Path(value = "/{language}")
135   def adminUpdateCrmLanguageTemplates: Route
136 
137   def routes: Route =
138     adminListCrmLanguageTemplates ~ adminCreateCrmLanguageTemplates ~ adminGetCrmLanguageTemplates ~ adminUpdateCrmLanguageTemplates
139 }
140 
141 trait AdminCrmLanguageTemplatesApiComponent {
142   def adminCrmLanguageTemplatesApi: AdminCrmLanguageTemplatesApi
143 }
144 
145 trait DefaultAdminCrmLanguageTemplatesApiComponent
146     extends AdminCrmLanguageTemplatesApiComponent
147     with MakeAuthenticationDirectives {
148   this: MakeDirectivesDependencies
149     with CrmTemplatesServiceComponent
150     with QuestionServiceComponent
151     with OperationServiceComponent =>
152 
153   val language: PathMatcher1[Language] = Segment.flatMap(lang => Try(Language(lang)).toOption)
154 
155   override lazy val adminCrmLanguageTemplatesApi: AdminCrmLanguageTemplatesApi = new DefaultAdminCrmLanguageTemplatesApi
156 
157   class DefaultAdminCrmLanguageTemplatesApi extends AdminCrmLanguageTemplatesApi {
158 
159     override def adminListCrmLanguageTemplates: Route = {
160       get {
161         path("admin" / "crm-templates" / "languages") {
162           makeOperation("AdminListCrmLanguageTemplates") { _ =>
163             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
164               requireAdminRole(userAuth.user) {
165                 crmTemplatesService.listByLanguage().asDirective { all =>
166                   complete((StatusCodes.OK, List(`X-Total-Count`(all.size.toString)), all.map {
167                     case (language, values) => CrmLanguageTemplates(language, values)
168                   }))
169                 }
170               }
171             }
172           }
173         }
174       }
175     }
176 
177     private def languagePredicate(id: Language): Boolean =
178       BusinessConfig.supportedCountries.exists(_.supportedLanguages.contains(id))
179 
180     override def adminCreateCrmLanguageTemplates: Route = post {
181       path("admin" / "crm-templates" / "languages") {
182         makeOperation("AdminCreateCrmLanguageTemplates") { _ =>
183           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
184             requireAdminRole(userAuth.user) {
185               decodeRequest {
186                 entity(as[CrmLanguageTemplates]) { request: CrmLanguageTemplates =>
187                   crmTemplatesService.get(request.id).asDirective { maybeCrmLanguageTemplates =>
188                     (
189                       request.id.predicateValidated(
190                         languagePredicate,
191                         fieldName = "id",
192                         key = "invalid_value",
193                         message = Some("Invalid language.")
194                       ),
195                       maybeCrmLanguageTemplates.predicateValidated(
196                         predicate = (_.isEmpty),
197                         fieldName = "id",
198                         key = "crm_templates_exist",
199                         message = Some("CRM templates already exist for this language.")
200                       )
201                     ).tupled.toValidationEither.fold(
202                       failWith(_), {
203                         case (id, maybeCrmLanguageTemplates) =>
204                           crmTemplatesService
205                             .create(request.id, request.values)
206                             .asDirective
207                             .apply(values => complete(StatusCodes.Created -> CrmLanguageTemplates(request.id, values)))
208                       }
209                     )
210                   }
211                 }
212               }
213             }
214           }
215         }
216       }
217     }
218 
219     override def adminGetCrmLanguageTemplates: Route = {
220       get {
221         path("admin" / "crm-templates" / "languages" / language) { language =>
222           makeOperation("AdminGetCrmLanguageTemplates") { _ =>
223             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
224               requireAdminRole(userAuth.user) {
225                 crmTemplatesService.get(language).asDirectiveOrNotFound { values =>
226                   complete(CrmLanguageTemplates(language, values))
227                 }
228               }
229             }
230           }
231         }
232       }
233     }
234 
235     override def adminUpdateCrmLanguageTemplates: Route = put {
236       path("admin" / "crm-templates" / "languages" / language) { language =>
237         makeOperation("AdminUpdateCrmLanguageTemplates") { _ =>
238           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
239             requireAdminRole(userAuth.user) {
240               decodeRequest {
241                 entity(as[CrmLanguageTemplates]) { request: CrmLanguageTemplates =>
242                   crmTemplatesService.get(language).asDirectiveOrNotFound { _ =>
243                     crmTemplatesService.update(language, request.values).asDirective { values =>
244                       complete(CrmLanguageTemplates(language, values))
245                     }
246                   }
247                 }
248               }
249             }
250           }
251         }
252       }
253     }
254   }
255 }
256 
257 final case class CrmLanguageTemplates(
258   @(ApiModelProperty @field)(dataType = "string", example = "fr", required = true) id: Language,
259   @(ApiModelProperty @field)(dataType = "string", example = "123456", required = true) registration: TemplateId,
260   @(ApiModelProperty @field)(dataType = "string", example = "123456", required = true) resendRegistration: TemplateId,
261   @(ApiModelProperty @field)(dataType = "string", example = "123456", required = true) welcome: TemplateId,
262   @(ApiModelProperty @field)(dataType = "string", example = "123456", required = true) proposalAccepted: TemplateId,
263   @(ApiModelProperty @field)(dataType = "string", example = "123456", required = true) proposalRefused: TemplateId,
264   @(ApiModelProperty @field)(dataType = "string", example = "123456", required = true) forgottenPassword: TemplateId,
265   @(ApiModelProperty @field)(dataType = "string", example = "123456", required = true) messageToProposer: TemplateId,
266   @(ApiModelProperty @field)(dataType = "string", example = "123456", required = true) messageToAbusiveWarn: TemplateId,
267   @(ApiModelProperty @field)(dataType = "string", example = "123456", required = true) messageToAbusiveBlock: TemplateId,
268   @(ApiModelProperty @field)(dataType = "string", example = "123456", required = true) voteOnlyNotice: TemplateId,
269   @(ApiModelProperty @field)(dataType = "string", example = "123456", required = true) endConsultationNotice: TemplateId,
270   @(ApiModelProperty @field)(dataType = "string", example = "123456", required = true) b2bProposalAccepted: TemplateId,
271   @(ApiModelProperty @field)(dataType = "string", example = "123456", required = true) b2bProposalRefused: TemplateId,
272   @(ApiModelProperty @field)(dataType = "string", example = "123456", required = true) b2bForgottenPassword: TemplateId,
273   @(ApiModelProperty @field)(dataType = "string", example = "123456", required = true) b2bRegistration: TemplateId,
274   @(ApiModelProperty @field)(dataType = "string", example = "123456", required = true) b2bEmailChangedConfirmation: TemplateId
275 ) {
276   def values: CrmTemplateKind => TemplateId = {
277     case CrmTemplateKind.Registration          => registration
278     case CrmTemplateKind.ResendRegistration    => resendRegistration
279     case CrmTemplateKind.Welcome               => welcome
280     case CrmTemplateKind.ProposalAccepted      => proposalAccepted
281     case CrmTemplateKind.ProposalRefused       => proposalRefused
282     case CrmTemplateKind.ForgottenPassword     => forgottenPassword
283     case CrmTemplateKind.MessageToProposer     => messageToProposer
284     case CrmTemplateKind.MessageToAbusiveWarn  => messageToAbusiveWarn
285     case CrmTemplateKind.MessageToAbusiveBlock => messageToAbusiveBlock
286     case CrmTemplateKind.VoteOnlyNotice        => voteOnlyNotice
287     case CrmTemplateKind.EndConsultationNotice => endConsultationNotice
288     case CrmTemplateKind.B2BProposalAccepted   => b2bProposalAccepted
289     case CrmTemplateKind.B2BProposalRefused    => b2bProposalRefused
290     case CrmTemplateKind.B2BForgottenPassword  => b2bForgottenPassword
291     case CrmTemplateKind.B2BRegistration       => b2bRegistration
292     case CrmTemplateKind.B2BEmailChanged       => b2bEmailChangedConfirmation
293   }
294 }
295 
296 object CrmLanguageTemplates {
297 
298   implicit val codec: Codec[CrmLanguageTemplates] = deriveCodec
299 
300   def apply(language: Language, templates: CrmTemplateKind => CrmLanguageTemplate): CrmLanguageTemplates =
301     CrmLanguageTemplates(
302       id = language,
303       registration = templates(CrmTemplateKind.Registration).template,
304       resendRegistration = templates(CrmTemplateKind.ResendRegistration).template,
305       welcome = templates(CrmTemplateKind.Welcome).template,
306       proposalAccepted = templates(CrmTemplateKind.ProposalAccepted).template,
307       proposalRefused = templates(CrmTemplateKind.ProposalRefused).template,
308       forgottenPassword = templates(CrmTemplateKind.ForgottenPassword).template,
309       messageToProposer = templates(CrmTemplateKind.MessageToProposer).template,
310       messageToAbusiveWarn = templates(CrmTemplateKind.MessageToAbusiveWarn).template,
311       messageToAbusiveBlock = templates(CrmTemplateKind.MessageToAbusiveBlock).template,
312       voteOnlyNotice = templates(CrmTemplateKind.VoteOnlyNotice).template,
313       endConsultationNotice = templates(CrmTemplateKind.EndConsultationNotice).template,
314       b2bProposalAccepted = templates(CrmTemplateKind.B2BProposalAccepted).template,
315       b2bProposalRefused = templates(CrmTemplateKind.B2BProposalRefused).template,
316       b2bForgottenPassword = templates(CrmTemplateKind.B2BForgottenPassword).template,
317       b2bRegistration = templates(CrmTemplateKind.B2BRegistration).template,
318       b2bEmailChangedConfirmation = templates(CrmTemplateKind.B2BEmailChanged).template
319     )
320 }