Mercurial > hg > LightPIT / file revision

 /*

  * Copyright 2021 Mike Becker. All rights reserved.

  *

  * Redistribution and use in source and binary forms, with or without

  * modification, are permitted provided that the following conditions are met:

  *

  * 1. Redistributions of source code must retain the above copyright

  * notice, this list of conditions and the following disclaimer.

  *

  * 2. Redistributions in binary form must reproduce the above copyright

  * notice, this list of conditions and the following disclaimer in the

  * documentation and/or other materials provided with the distribution.

  *

  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  */

 package de.uapcore.lightpit.viewmodel

 import com.vladsch.flexmark.ext.gfm.strikethrough.StrikethroughExtension

 import com.vladsch.flexmark.ext.tables.TablesExtension

 import com.vladsch.flexmark.html.HtmlRenderer

 import com.vladsch.flexmark.parser.Parser

 import com.vladsch.flexmark.util.data.MutableDataSet

 import com.vladsch.flexmark.util.data.SharedDataKeys

 import de.uapcore.lightpit.HttpRequest

 import de.uapcore.lightpit.entities.*

 import de.uapcore.lightpit.types.*

 import kotlin.math.roundToInt

 class IssueSorter(private vararg val criteria: Criteria) : Comparator<Issue> {

     enum class Field {

         DONE, PHASE, STATUS, CATEGORY, ETA, UPDATED, CREATED;

         val resourceKey: String by lazy {

             if (this == DONE) "issue.filter.sort.done"

             else if (this == PHASE) "issue.filter.sort.phase"

             else "issue.${this.name.lowercase()}"

         }

     }

     data class Criteria(val field: Field, val asc: Boolean = true) {

         override fun toString(): String {

             return "$field.$asc"

         }

     }

     override fun compare(left: Issue, right: Issue): Int {

         if (left == right) {

             return 0

         }

         for (c in criteria) {

             val result = when (c.field) {

                 Field.PHASE -> left.status.phase.compareTo(right.status.phase)

                 Field.DONE -> (left.status.phase == IssueStatusPhase.Done).compareTo(right.status.phase == IssueStatusPhase.Done)

                 Field.STATUS -> left.status.compareTo(right.status)

                 Field.CATEGORY -> left.category.compareTo(right.category)

                 Field.ETA -> left.compareEtaTo(right.eta)

                 Field.UPDATED -> left.updated.compareTo(right.updated)

                 Field.CREATED -> left.created.compareTo(right.created)

             }

             if (result != 0) {

                 return if (c.asc) result else -result

             }

         }

         return 0

     }

 }

 class IssueSummary {

     var open = 0

     var active = 0

     var done = 0

     val total get() = open + active + done

     val openPercent get() = 100 - activePercent - donePercent

     val activePercent get() = if (total > 0) (100f * active / total).roundToInt() else 0

     val donePercent get() = if (total > 0) (100f * done / total).roundToInt() else 100

     /**

      * Adds the specified issue to the summary by incrementing the respective counter.

      * @param issue the issue

      */

     fun add(issue: Issue) {

         when (issue.status.phase) {

             IssueStatusPhase.Open -> open++

             IssueStatusPhase.WorkInProgress -> active++

             IssueStatusPhase.Done -> done++

         }

     }

 }

 class IssueDetailView(

     val issue: Issue,

     val comments: List<IssueComment>,

     val project: Project,

     val version: Version?,

     val component: Component?,

     projectIssues: List<Issue>,

     val currentRelations: List<IssueRelation>,

     /**

      * Optional resource key to an error message for the relation editor.

      */

     val relationError: String?

 ) : View() {

     val relationTypes = RelationType.values()

     val linkableIssues = projectIssues.filterNot { it.id == issue.id }

     private val parser: Parser

     private val renderer: HtmlRenderer

     init {

         val options = MutableDataSet()

             .set(SharedDataKeys.EXTENSIONS, listOf(TablesExtension.create(), StrikethroughExtension.create()))

         parser = Parser.builder(options).build()

         renderer = HtmlRenderer.builder(

             options

                 .set(HtmlRenderer.ESCAPE_HTML, true)

         ).build()

         issue.description = formatMarkdown(issue.description ?: "")

         for (comment in comments) {

             comment.commentFormatted = formatMarkdown(comment.comment)

         }

     }

     private fun formatEmojis(text: String) = text

         .replace("(/)", "✅")

         .replace("(x)", "❌")

         .replace("(!)", "⚡")

     private fun formatMarkdown(text: String) =

         renderer.render(parser.parse(formatEmojis(text)))

 }

 class IssueEditView(

     val issue: Issue,

     val versions: List<Version>,

     val components: List<Component>,

     val users: List<User>,

     val project: Project, // TODO: allow null values to create issues from the IssuesServlet

     val version: Version? = null,

     val component: Component? = null

 ) : EditView() {

     val versionsUpcoming: List<Version>

     val versionsRecent: List<Version>

     val issueStatus = IssueStatus.values()

     val issueCategory = IssueCategory.values()

     init {

         val recent = mutableListOf<Version>()

         issue.affected?.let { recent.add(it) }

         val upcoming = mutableListOf<Version>()

         issue.resolved?.let { upcoming.add(it) }

         for (v in versions) {

             if (v.status.isReleased) {

                 if (v.status != VersionStatus.Deprecated) recent.add(v)

             } else {

                 upcoming.add(v)

             }

         }

         versionsRecent = recent.distinct()

         versionsUpcoming = upcoming.distinct()

     }

 }

 class IssueFilter(http: HttpRequest) {

     val issueStatus = IssueStatus.values()

     val issueCategory = IssueCategory.values()

     val sortCriteria = IssueSorter.Field.values().flatMap { listOf(IssueSorter.Criteria(it, true), IssueSorter.Criteria(it, false)) }

     val flagIncludeDone = "f.0"

     val flagMine = "f.1"

     val flagBlocker = "f.2"

     val includeDone: Boolean = evalFlag(http, flagIncludeDone)

     val onlyMine: Boolean = evalFlag(http, flagMine)

     val onlyBlocker: Boolean = evalFlag(http, flagBlocker)

     val status: List<IssueStatus> = evalEnum(http, "s")

     val category: List<IssueCategory> = evalEnum(http, "c")

     val sortPrimary: IssueSorter.Criteria = evalSort(http, "primary", IssueSorter.Criteria(IssueSorter.Field.DONE))

     val sortSecondary: IssueSorter.Criteria = evalSort(http, "secondary", IssueSorter.Criteria(IssueSorter.Field.ETA))

     val sortTertiary: IssueSorter.Criteria = evalSort(http, "tertiary", IssueSorter.Criteria(IssueSorter.Field.UPDATED, false))

     private fun evalSort(http: HttpRequest, prio: String, defaultValue: IssueSorter.Criteria): IssueSorter.Criteria {

         val param = http.param("sort_$prio")

         if (param != null) {

             http.session.removeAttribute("sort_$prio")

             val p = param.split(".")

             if (p.size > 1) {

                 try {

                     http.session.setAttribute("sort_$prio", IssueSorter.Criteria(enumValueOf(p[0]), p[1].toBoolean()))

                 } catch (_:IllegalArgumentException) {

                     // ignore malfored values

                 }

             }

         }

         return http.session.getAttribute("sort_$prio") as IssueSorter.Criteria? ?: defaultValue

     }

     private fun evalFlag(http: HttpRequest, name: String): Boolean {

         val param = http.paramArray("filter")

         if (param.isNotEmpty()) {

             if (param.contains(name)) {

                 http.session.setAttribute(name, true)

             } else {

                 http.session.removeAttribute(name)

             }

         }

         return http.session.getAttribute(name) != null

     }

     private inline fun <reified T : Enum<T>> evalEnum(http: HttpRequest, prefix: String): List<T> {

         val sattr = "f.${prefix}"

         val param = http.paramArray("filter")

         if (param.isNotEmpty()) {

             val list = param.filter { it.startsWith("${prefix}.") }

                 .map { it.substring(prefix.length + 1) }

                 .map {

                     try {

                         // quick and very dirty validation

                         enumValueOf<T>(it)

                     } catch (_: IllegalArgumentException) {

                         // skip

                     }

                 }

             if (list.isEmpty()) {

                 http.session.removeAttribute(sattr)

             } else {

                 http.session.setAttribute(sattr, list.joinToString(","))

             }

         }

         return http.session.getAttribute(sattr)

             ?.toString()

             ?.split(",")

             ?.map { enumValueOf(it) }

             ?: emptyList()

     }

 }