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.core.technical
21 package generator
22 
23 import _root_.enumeratum.values.scalacheck._
24 import cats.data.{NonEmptyList => Nel}
25 import cats.implicits._
26 import eu.timepit.refined.refineV
27 import eu.timepit.refined.api.{RefType, Refined}
28 import eu.timepit.refined.auto._
29 import eu.timepit.refined.collection._
30 import eu.timepit.refined.scalacheck.numeric._
31 import eu.timepit.refined.types.numeric.{NonNegInt, PosInt}
32 import org.make.core.DateHelper._
33 import org.make.core.job.Job
34 import org.make.core.job.Job.{JobId, JobStatus}
35 import org.make.core.operation._
36 import org.make.core.proposal._
37 import org.make.core.question.{Question, QuestionId}
38 import org.make.core.reference.{Country, Language}
39 import org.make.core.tag.{Tag, TagDisplay, TagId, TagTypeId}
40 import org.make.core.technical.generator.CustomGenerators.ImageUrl
41 import org.make.core.user.{Role, User, UserType}
42 import org.make.core.{BusinessConfig, DateHelper, RequestContext, RequestContextLanguage, SlugHelper}
43 import org.scalacheck.Arbitrary.arbitrary
44 import org.scalacheck.{Arbitrary, Gen}
45 
46 import java.net.URI
47 import java.time.temporal.ChronoUnit
48 import java.time.{Period, ZoneOffset, ZonedDateTime}
49 import scala.concurrent.duration.FiniteDuration
50 
51 trait EntitiesGen extends DateGenerators {
52 
53   def genCountryLanguage: Gen[(Country, Language)] =
54     Gen.oneOf(for {
55       supportedCountry <- BusinessConfig.supportedCountries
56       language         <- supportedCountry.supportedLanguages
57     } yield (supportedCountry.countryCode, language))
58 
59   def genCountriesLanguage(
60     forceCountries: Option[Nel[Country]],
61     forceLanguage: Option[Language]
62   ): Gen[(Nel[Country], Nel[Language])] =
63     (forceCountries, forceLanguage) match {
64       case (Some(countries), Some(language)) => countries -> Nel.of(language)
65       case (Some(countries), None) =>
66         Gen.oneOf(
67           BusinessConfig.supportedCountries
68             .filter(conf => countries.exists(_ == conf.countryCode))
69             .map(c => countries -> Nel.of(c.defaultLanguage))
70         )
71       case (None, Some(language)) =>
72         BusinessConfig.supportedCountries
73           .find(_.supportedLanguages.contains(language))
74           .fold(Gen.oneOf(BusinessConfig.supportedCountries.map(conf => Nel.of(conf.countryCode) -> Nel.of(language))))(
75             conf => Gen.const(Nel.of(conf.countryCode) -> Nel.of(language))
76           )
77       case (None, None) => genCountryLanguage.map { case (country, language) => Nel.of(country) -> Nel.of(language) }
78     }
79 
80   Gen.oneOf(for {
81     supportedCountry <- BusinessConfig.supportedCountries
82     language         <- supportedCountry.supportedLanguages
83   } yield (supportedCountry.countryCode, language))
84 
85   def genSimpleOperation: Gen[SimpleOperation] =
86     for {
87       slug          <- CustomGenerators.LoremIpsumGen.slug(maxLength = Some(20))
88       operationKind <- arbitrary[OperationKind]
89       date          <- Gen.calendar.map(_.toZonedDateTime)
90     } yield SimpleOperation(
91       operationId = IdGenerator.uuidGenerator.nextOperationId(),
92       slug = slug,
93       operationKind = operationKind,
94       operationAuthentication = None,
95       createdAt = Some(date),
96       updatedAt = Some(date)
97     )
98 
99   private def genQuestion(operationId: Option[OperationId]): Gen[Question] =
100     for {
101       slug                <- CustomGenerators.LoremIpsumGen.slug(maxLength = Some(30))
102       (country, language) <- genCountryLanguage
103       question            <- CustomGenerators.LoremIpsumGen.sentence()
104       shortTitle          <- CustomGenerators.LoremIpsumGen.sentence(maxLength = Some(30))
105     } yield Question(
106       questionId = IdGenerator.uuidGenerator.nextQuestionId(),
107       slug = slug,
108       countries = Nel.of(country),
109       defaultLanguage = language,
110       languages = Nel.of(language),
111       questions = Multilingual(language -> refineV[NonEmpty](question).getOrElse("?": String Refined NonEmpty)),
112       shortTitles =
113         Some(Multilingual(language -> refineV[NonEmpty](shortTitle).getOrElse("?": String Refined NonEmpty))),
114       operationId = operationId
115     )
116 
117   private def genTimelineElement(fromDate: ZonedDateTime): Gen[TimelineElement] =
118     for {
119       date        <- genDateWithOffset(lowerOffset = Period.ofYears(0), upperOffset = Period.ofYears(3), fromDate = fromDate)
120       dateText    <- CustomGenerators.LoremIpsumGen.sentence(Some(20)).map(refineV[MaxSize[20]].unsafeFrom(_))
121       description <- CustomGenerators.LoremIpsumGen.sentence(Some(150)).map(refineV[MaxSize[150]].unsafeFrom(_))
122     } yield TimelineElement(
123       date = date.toLocalDate,
124       dateTexts = Multilingual.fromDefault(dateText),
125       descriptions = Multilingual.fromDefault(description)
126     )
127 
128   private def genOOQTimeline(startDate: ZonedDateTime): Gen[OperationOfQuestionTimeline] =
129     for {
130       result <- genTimelineElement(startDate).asOption
131       action <- genTimelineElement(result.fold(startDate)(_.date.atStartOfDay(ZoneOffset.UTC))).asOption
132       workshop <- genTimelineElement(
133         action
134           .map(_.date.atStartOfDay(ZoneOffset.UTC))
135           .orElse(result.map(_.date.atStartOfDay(ZoneOffset.UTC)))
136           .getOrElse(startDate)
137       ).asOption
138     } yield OperationOfQuestionTimeline(action = action, result = result, workshop = workshop)
139 
140   def genOperationOfQuestion: Gen[OperationOfQuestion] =
141     for {
142       operation <- genSimpleOperation
143       question  <- genQuestion(Some(operation.operationId))
144       startDate <- genDateWithOffset(lowerOffset = Period.ofYears(-3), upperOffset = Period.ofYears(1))
145       endDate <- genDateWithOffset(
146         lowerOffset = Period.ofMonths(1),
147         upperOffset = Period.ofMonths(6),
148         fromDate = startDate
149       )
150       title             <- CustomGenerators.LoremIpsumGen.sentence()
151       proposalPrefix    <- CustomGenerators.LoremIpsumGen.sentence(maxLength = Some(15))
152       canPropose        <- arbitrary[Boolean]
153       resultsLink       <- genResultsLink.asOption
154       proposalsCount    <- arbitrary[NonNegInt]
155       participantsCount <- arbitrary[NonNegInt]
156       featured          <- arbitrary[Boolean]
157       votesTarget       <- Gen.choose(0, 100_000_000)
158       votesCount        <- Gen.choose(0, 100_000_000)
159       timeline          <- genOOQTimeline(startDate)
160     } yield {
161       val language = question.languages.head
162       OperationOfQuestion(
163         questionId = question.questionId,
164         operationId = operation.operationId,
165         startDate = startDate,
166         endDate = endDate,
167         operationTitles = Multilingual(language -> title),
168         proposalPrefixes = Multilingual(language -> proposalPrefix),
169         canPropose = canPropose,
170         sequenceCardsConfiguration = SequenceCardsConfiguration.default,
171         aboutUrls = None,
172         metas = Metas(None, None, None),
173         theme = QuestionTheme.default,
174         descriptions = None,
175         consultationImages = None,
176         consultationImageAlts = None,
177         descriptionImages = None,
178         descriptionImageAlts = None,
179         partnersLogos = None,
180         partnersLogosAlt = None,
181         initiatorsLogos = None,
182         initiatorsLogosAlt = None,
183         consultationHeader = None,
184         consultationHeaderAlts = None,
185         cobrandingLogo = None,
186         cobrandingLogoAlt = None,
187         resultsLink = resultsLink,
188         proposalsCount = proposalsCount,
189         participantsCount = participantsCount,
190         actions = None,
191         featured = featured,
192         votesCount = votesCount,
193         votesTarget = votesTarget,
194         timeline = timeline,
195         createdAt = DateHelper.now(),
196         sessionBindingMode = false,
197         reportUrl = None,
198         actionsUrl = None
199       )
200     }
201 
202   private val genResultsLink: Gen[ResultsLink] = Gen.frequency(
203     (4, Gen.oneOf(ResultsLink.Internal.values)),
204     (1, ImageUrl.gen(100, 100).map(url => ResultsLink.External(new URI(url))))
205   )
206 
207   def genRoles: Gen[Seq[Role]] = {
208     val roles = Gen.frequency(
209       (1, Role.RoleActor),
210       (1, Role.RoleAdmin),
211       (9, Role.RoleCitizen),
212       (2, Role.RoleModerator),
213       (1, Role.RolePolitical)
214     )
215     Gen.listOfN(3, roles).map(_.distinct)
216   }
217 
218   private val SumCounterUpperBound = 600
219   private val SimpleCountUpperBound = SumCounterUpperBound / 3
220   private def getMaxCount(getter: Counts => Int, countsNel: Nel[Counts]): Int =
221     getter(countsNel.maximumBy(getter))
222 
223   private def genSimpleCounts: Gen[Counts] =
224     for {
225       count         <- Gen.chooseNum(0, SimpleCountUpperBound)
226       countVerified <- Gen.chooseNum(0, count)
227       countSequence <- Gen.chooseNum(0, countVerified)
228       countSegment  <- Gen.chooseNum(0, countSequence)
229     } yield Counts(count, countVerified, countSequence, countSegment)
230 
231   private def genSumCounts(counters: Nel[Counts]): Gen[Counts] =
232     for {
233       count         <- Gen.chooseNum(getMaxCount(_.count, counters), SumCounterUpperBound)
234       countVerified <- Gen.chooseNum(getMaxCount(_.verified, counters), count)
235       countSequence <- Gen.chooseNum(getMaxCount(_.sequence, counters), countVerified)
236       countSegment  <- Gen.chooseNum(getMaxCount(_.segment, counters), countSequence)
237     } yield Counts(count, countVerified, countSequence, countSegment)
238 
239   private def genProposalVotes: Gen[VotingOptions] =
240     for {
241       likeItCounts            <- genSimpleCounts
242       doableCounts            <- genSimpleCounts
243       platitudeAgreeCounts    <- genSimpleCounts
244       agreeCounts             <- genSumCounts(Nel.of(likeItCounts, doableCounts, platitudeAgreeCounts))
245       doNotUnderstandCounts   <- genSimpleCounts
246       doNotCareCounts         <- genSimpleCounts
247       noOpinionCounts         <- genSimpleCounts
248       neutralCounts           <- genSumCounts(Nel.of(doNotUnderstandCounts, doNotCareCounts, noOpinionCounts))
249       noWayCounts             <- genSimpleCounts
250       impossibleCount         <- genSimpleCounts
251       platitudeDisagreeCounts <- genSimpleCounts
252       disagreeCounts          <- genSumCounts(Nel.of(noWayCounts, impossibleCount, platitudeDisagreeCounts))
253     } yield VotingOptions(
254       AgreeWrapper(
255         vote = Vote(
256           key = VoteKey.Agree,
257           count = agreeCounts.count,
258           countVerified = agreeCounts.verified,
259           countSequence = agreeCounts.sequence,
260           countSegment = agreeCounts.segment
261         ),
262         likeIt = Qualification(
263           QualificationKey.LikeIt,
264           likeItCounts.count,
265           likeItCounts.verified,
266           likeItCounts.sequence,
267           likeItCounts.segment
268         ),
269         doable = Qualification(
270           QualificationKey.Doable,
271           doableCounts.count,
272           doableCounts.verified,
273           doableCounts.sequence,
274           doableCounts.segment
275         ),
276         platitudeAgree = Qualification(
277           QualificationKey.PlatitudeAgree,
278           platitudeAgreeCounts.count,
279           platitudeAgreeCounts.verified,
280           platitudeAgreeCounts.sequence,
281           platitudeAgreeCounts.segment
282         )
283       ),
284       NeutralWrapper(
285         vote = Vote(
286           key = VoteKey.Neutral,
287           count = neutralCounts.count,
288           countVerified = neutralCounts.verified,
289           countSequence = neutralCounts.sequence,
290           countSegment = neutralCounts.segment
291         ),
292         doNotUnderstand = Qualification(
293           QualificationKey.DoNotUnderstand,
294           doNotUnderstandCounts.count,
295           doNotUnderstandCounts.verified,
296           doNotUnderstandCounts.sequence,
297           doNotUnderstandCounts.segment
298         ),
299         doNotCare = Qualification(
300           QualificationKey.DoNotCare,
301           doNotCareCounts.count,
302           doNotCareCounts.verified,
303           doNotCareCounts.sequence,
304           doNotCareCounts.segment
305         ),
306         noOpinion = Qualification(
307           QualificationKey.NoOpinion,
308           noOpinionCounts.count,
309           noOpinionCounts.verified,
310           noOpinionCounts.sequence,
311           noOpinionCounts.segment
312         )
313       ),
314       DisagreeWrapper(
315         vote = Vote(
316           key = VoteKey.Disagree,
317           count = disagreeCounts.count,
318           countVerified = disagreeCounts.verified,
319           countSequence = disagreeCounts.sequence,
320           countSegment = disagreeCounts.segment
321         ),
322         noWay = Qualification(
323           QualificationKey.NoWay,
324           noWayCounts.count,
325           noWayCounts.verified,
326           noWayCounts.sequence,
327           noWayCounts.segment
328         ),
329         impossible = Qualification(
330           QualificationKey.Impossible,
331           impossibleCount.count,
332           impossibleCount.verified,
333           impossibleCount.sequence,
334           impossibleCount.segment
335         ),
336         platitudeDisagree = Qualification(
337           QualificationKey.PlatitudeDisagree,
338           disagreeCounts.count,
339           disagreeCounts.verified,
340           disagreeCounts.sequence,
341           disagreeCounts.segment
342         )
343       )
344     )
345 
346   implicit val arbProposalStatus: Arbitrary[ProposalStatus] = Arbitrary(
347     Gen.frequency(
348       (10, ProposalStatus.Pending),
349       (5, ProposalStatus.Postponed),
350       (70, ProposalStatus.Accepted),
351       (14, ProposalStatus.Refused),
352       (1, ProposalStatus.Archived)
353     )
354   )
355 
356   implicit val arbProposalType: Arbitrary[ProposalType] = Arbitrary(
357     Gen.frequency(
358       (70, ProposalType.ProposalTypeSubmitted),
359       (25, ProposalType.ProposalTypeInitial),
360       (5, ProposalType.ProposalTypeExternal)
361     )
362   )
363 
364   def genProposal(question: Question, users: Seq[User], tagsIds: Seq[TagId]): Gen[Proposal] = {
365     val maxLength: Option[PosInt] = RefType.applyRef[PosInt](BusinessConfig.defaultProposalMaxLength).toOption
366     for {
367       content         <- CustomGenerators.LoremIpsumGen.sentence(maxLength).map(sentence => s"Il faut ${sentence.toLowerCase}")
368       author          <- Gen.oneOf(users.map(_.userId))
369       status          <- arbitrary[ProposalStatus]
370       refusalReason   <- CustomGenerators.LoremIpsumGen.word
371       tags            <- Gen.someOf(tagsIds)
372       votes           <- genProposalVotes
373       organisationIds <- Gen.someOf(users.filter(_.userType == UserType.UserTypeOrganisation).map(_.userId))
374       date            <- Gen.calendar.map(_.toZonedDateTime).asOption
375       initialProposal <- Gen.frequency((9, false), (1, true))
376       isAnonymous     <- Gen.oneOf(true, false)
377       proposalType    <- arbitrary[ProposalType]
378       keywords        <- Gen.listOf(genKeyword)
379       country         <- Gen.option(Gen.oneOf(question.countries.toList))
380       language        <- Gen.oneOf(question.languages.toList)
381     } yield Proposal(
382       proposalId = IdGenerator.uuidGenerator.nextProposalId(),
383       slug = SlugHelper(content),
384       content = content,
385       submittedAsLanguage = Some(language),
386       contentTranslations = None,
387       author = author,
388       status = status,
389       refusalReason = if (status == ProposalStatus.Refused) Some(refusalReason) else None,
390       tags = tags.toSeq,
391       isAnonymous = isAnonymous,
392       votingOptions = Some(votes),
393       organisationIds = organisationIds.toSeq,
394       questionId = Some(question.questionId),
395       creationContext = RequestContext.empty
396         .copy(country = country, languageContext = RequestContextLanguage(language = Some(question.languages.head))),
397       idea = None,
398       operation = question.operationId,
399       proposalType = proposalType,
400       createdAt = date,
401       updatedAt = date,
402       validatedAt = date.filter(_ => status == ProposalStatus.Accepted || status == ProposalStatus.Refused),
403       postponedAt = date.filter(_ => status == ProposalStatus.Postponed),
404       events = List.empty,
405       initialProposal = initialProposal,
406       keywords = keywords
407     )
408   }
409 
410   val genJob: Gen[Job] = {
411     val genJobStatus: Gen[JobStatus] = Gen.oneOf(
412       Arbitrary.arbitrary[Job.Progress].map(JobStatus.Running.apply),
413       Arbitrary.arbitrary[Option[String]].map(JobStatus.Finished.apply)
414     )
415     for {
416       id        <- Gen.uuid
417       status    <- genJobStatus
418       createdAt <- genDateWithOffset(lowerOffset = Period.ofYears(-2), upperOffset = Period.ZERO).asOption
419       update <- Arbitrary
420         .arbitrary[Option[FiniteDuration]]
421         .map(_.flatMap(u => createdAt.map(_.plusNanos(u.toNanos).truncatedTo(ChronoUnit.MILLIS))))
422     } yield Job(JobId(id.toString), status, createdAt, update)
423   }
424 
425   private val stake = TagTypeId("c0d8d858-8b04-4dd9-add6-fa65443b622b")
426   private val solution = TagTypeId("cc6a16a5-cfa7-495b-a235-08affb3551af")
427   private val moment = TagTypeId("5e539923-c265-45d2-9d0b-77f29c8b0a06")
428   private val target = TagTypeId("226070ac-51b0-4e92-883a-f0a24d5b8525")
429   private val actor = TagTypeId("982e6860-eb66-407e-bafb-461c2d927478")
430   private val legacy = TagTypeId("8405aba4-4192-41d2-9a0d-b5aa6cb98d37")
431 
432   def genTag(operationId: Option[OperationId], questionId: Option[QuestionId]): Gen[Tag] =
433     for {
434       label     <- CustomGenerators.LoremIpsumGen.sentence(maxLength = Some(20))
435       weight    <- Gen.posNum[Float]
436       display   <- Gen.frequency((8, TagDisplay.Inherit), (1, TagDisplay.Displayed), (1, TagDisplay.Hidden))
437       tagTypeId <- Gen.oneOf(Seq(stake, solution, moment, target, actor, legacy))
438     } yield Tag(
439       tagId = IdGenerator.uuidGenerator.nextTagId(),
440       label = label,
441       display = display,
442       tagTypeId = tagTypeId,
443       weight = weight,
444       operationId = operationId,
445       questionId = questionId
446     )
447 
448   private def genKeyword: Gen[ProposalKeyword] = {
449     for {
450       key   <- CustomGenerators.LoremIpsumGen.word.map(ProposalKeywordKey.apply)
451       label <- CustomGenerators.LoremIpsumGen.word
452     } yield ProposalKeyword(key = key, label = label)
453   }
454 
455 }
456 
457 final case class Counts(count: Int, verified: Int, sequence: Int, segment: Int)