LightPIT: src/main/kotlin/de/uapcore/lightpit/viewmodel/Issues.kt@703591e739f4 (annotated)

src/main/kotlin/de/uapcore/lightpit/viewmodel/Issues.kt@703591e739f4 (annotated)

src/main/kotlin/de/uapcore/lightpit/viewmodel/Issues.kt

Mon, 30 Oct 2023 14:44:36 +0100

author: Mike Becker <universe@uap-core.de>
date: Mon, 30 Oct 2023 14:44:36 +0100
changeset 292: 703591e739f4
parent 291: bcf05cccac6f
permissions: -rw-r--r--

add possibility to show issues w/o version or component - fixes #335

 /*
  * 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++
         }
     }
 }
 data class CommitLink(val url: String, val hash: String, val message: String)
 class IssueDetailView(
     val pathInfos: PathInfos,
     val issue: Issue,
     val comments: List<IssueComment>,
     val project: Project,
     projectIssues: List<Issue>,
     val currentRelations: List<IssueRelation>,
     /**
      * Optional resource key to an error message for the relation editor.
      */
     val relationError: String?,
     commitRefs: List<CommitRef>
 ) : View() {
     val relationTypes = RelationType.entries
     val linkableIssues = projectIssues.filterNot { it.id == issue.id }
     val commitLinks: List<CommitLink>
     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)
         }
         val commitBaseUrl = project.repoUrl
         commitLinks = (if (commitBaseUrl == null || project.vcs == VcsType.None) emptyList() else commitRefs.map {
             CommitLink(buildCommitUrl(commitBaseUrl, project.vcs, it.hash), it.hash, it.message)
         })
     }
     private fun buildCommitUrl(baseUrl: String, vcs: VcsType, hash: String): String =
         with (StringBuilder(baseUrl)) {
             if (!endsWith("/")) append('/')
             when (vcs) {
                 VcsType.Mercurial -> append("rev/")
                 else -> append("commit/")
             }
             append(hash)
             toString()
         }
     private fun formatEmojis(text: String) = text
         .replace("(/)", "&#9989;")
         .replace("(x)", "&#10060;")
         .replace("(!)", "&#9889;")
     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 pathInfos: PathInfos
 ) : EditView() {
     val versionsUpcoming: List<Version>
     val versionsRecent: List<Version>
     val issueStatus = IssueStatus.entries
     val issueCategory = IssueCategory.entries
     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.entries
     val issueCategory = IssueCategory.entries
     val sortCriteria = IssueSorter.Field.entries.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()
     }
 }

Mercurial > hg > LightPIT / annotate

src/main/kotlin/de/uapcore/lightpit/viewmodel/Issues.kt@703591e739f4 (annotated)

src/main/kotlin/de/uapcore/lightpit/viewmodel/Issues.kt