Issues on the phone: read, comment, close and reopen, labels, and new issues (refs #4) 31e4f3755627

package io.oxygenhub.android.ui.issues

import androidx.compose.foundation.layout.Arrangement

import androidx.compose.foundation.layout.Column

import androidx.compose.foundation.layout.ExperimentalLayoutApi

import androidx.compose.foundation.layout.FlowRow

import androidx.compose.foundation.layout.Row

import androidx.compose.foundation.layout.fillMaxWidth

import androidx.compose.foundation.layout.imePadding

import androidx.compose.foundation.layout.padding

import androidx.compose.foundation.lazy.LazyColumn

import androidx.compose.foundation.lazy.items

import androidx.compose.material.icons.Icons

import androidx.compose.material.icons.automirrored.outlined.Label

import androidx.compose.material3.AlertDialog

import androidx.compose.material3.Button

import androidx.compose.material3.Checkbox

import androidx.compose.material3.ElevatedCard

import androidx.compose.material3.HorizontalDivider

import androidx.compose.material3.Icon

import androidx.compose.material3.IconButton

import androidx.compose.material3.MaterialTheme

import androidx.compose.material3.OutlinedButton

import androidx.compose.material3.OutlinedTextField

import androidx.compose.material3.Text

import androidx.compose.material3.TextButton

import androidx.compose.runtime.Composable

import androidx.compose.runtime.LaunchedEffect

import androidx.compose.runtime.getValue

import androidx.compose.runtime.mutableStateListOf

import androidx.compose.runtime.mutableStateOf

import androidx.compose.runtime.remember

import androidx.compose.runtime.saveable.rememberSaveable

import androidx.compose.runtime.setValue

import androidx.compose.ui.Alignment

import androidx.compose.ui.Modifier

import androidx.compose.ui.unit.dp

import androidx.lifecycle.compose.collectAsStateWithLifecycle

import com.mikepenz.markdown.m3.Markdown

import io.oxygenhub.android.api.Comment

import io.oxygenhub.android.ui.common.AppScreen

import io.oxygenhub.android.ui.common.Load

import io.oxygenhub.android.ui.common.LoadContent

import io.oxygenhub.android.ui.common.relativeTime

import io.oxygenhub.android.ui.theme.LocalStatusColors

/**

 * An issue (#4): its body and comments rendered, its labels and

 * assignees; comment, close or reopen, and change its labels, when the

 * session may write.

 */

@OptIn(ExperimentalLayoutApi::class)

@Composable

fun IssueScreen(vm: IssueViewModel, canWrite: Boolean, onBack: () -> Unit) {

    val state by vm.state.collectAsStateWithLifecycle()

    val working by vm.working.collectAsStateWithLifecycle()

    val error by vm.error.collectAsStateWithLifecycle()

    var picking by remember { mutableStateOf(false) }

    val status = LocalStatusColors.current

    AppScreen(

        title = "#${vm.number}",

        subtitle = "${vm.owner}/${vm.name}",

        onBack = onBack,

        actions = {

            if (canWrite) {

                IconButton(onClick = {

                    vm.loadLabels()

                    picking = true

                }) { Icon(Icons.AutoMirrored.Outlined.Label, contentDescription = "Labels") }

            }

        },

    ) {

        LoadContent(state, onRefresh = vm::refresh) { t ->

            val i = t.issue

            LazyColumn(Modifier.imePadding()) {

                item {

                    Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {

                        Text(i.title, style = MaterialTheme.typography.titleLarge)

                        Text(

                            (if (i.isOpen) "Open" else "Closed" + if (i.reason == "not_planned") " (not planned)" else "") +

                                " · opened ${relativeTime(i.createdMs)} by ${i.author}",

                            color = if (i.isOpen) status.ok else status.warn,

                            style = MaterialTheme.typography.bodyMedium,

                        )

                        if (i.labels.isNotEmpty()) {

                            FlowRow(horizontalArrangement = Arrangement.spacedBy(4.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) {

                                i.labels.forEach { LabelChip(it) }

                            }

                        }

                        if (i.assignees.isNotEmpty()) Text("Assigned to " + i.assignees.joinToString(", "), style = MaterialTheme.typography.bodySmall)

                        i.milestone?.let { Text("Milestone: $it", style = MaterialTheme.typography.bodySmall) }

                        if (i.body.isNotBlank()) Markdown(i.body) else Text("No description.", color = MaterialTheme.colorScheme.onSurfaceVariant)

                    }

                    HorizontalDivider()

                }

                items(t.comments, key = { it.id }) { c -> CommentCard(c) }

                item {

                    error?.let {

                        Text(it, color = MaterialTheme.colorScheme.error, modifier = Modifier.padding(horizontal = 16.dp, vertical = 4.dp))

                    }

                    if (canWrite && !i.locked) {

                        CommentBox(working, isOpen = i.isOpen, onComment = { body, done -> vm.comment(body, done) }, onClose = { vm.close() }, onReopen = vm::reopen)

                    } else if (i.locked) {

                        Text("Locked: only collaborators may comment.", modifier = Modifier.padding(16.dp))

                    }

                }

            }

        }

    }

    if (picking) {

        LabelPicker(vm, current = (state as? Load.Ready)?.value?.issue?.labels?.map { it.name }.orEmpty(), onDone = { picking = false })

    }

}

@Composable

private fun CommentCard(c: Comment) {

    ElevatedCard(Modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 6.dp)) {

        Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) {

            Text("${c.author} · ${relativeTime(c.createdMs)}", style = MaterialTheme.typography.labelMedium)

            Markdown(c.body)

        }

    }

}

@Composable

private fun CommentBox(working: Boolean, isOpen: Boolean, onComment: (String, (Boolean) -> Unit) -> Unit, onClose: () -> Unit, onReopen: () -> Unit) {

    var text by rememberSaveable { mutableStateOf("") }

    Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {

        OutlinedTextField(text, { text = it }, label = { Text("Comment (Markdown)") }, modifier = Modifier.fillMaxWidth(), minLines = 3)

        Row(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically) {

            Button(enabled = !working && text.isNotBlank(), onClick = { onComment(text) { ok -> if (ok) text = "" } }) { Text("Comment") }

            if (isOpen) {

                OutlinedButton(enabled = !working, onClick = onClose) { Text("Close issue") }

            } else {

                OutlinedButton(enabled = !working, onClick = onReopen) { Text("Reopen") }

            }

        }

    }

}

/** The repository's labels, ticked where the issue has them; saved as the whole set. */

@Composable

private fun LabelPicker(vm: IssueViewModel, current: List<String>, onDone: () -> Unit) {

    val labels by vm.labels.collectAsStateWithLifecycle()

    val chosen = remember { mutableStateListOf<String>().apply { addAll(current) } }

    LaunchedEffect(Unit) { vm.loadLabels() }

    AlertDialog(

        onDismissRequest = onDone,

        title = { Text("Labels") },

        text = {

            when (val l = labels) {

                is Load.Ready -> LazyColumn {

                    items(l.value, key = { it.name }) { label ->

                        Row(verticalAlignment = Alignment.CenterVertically) {

                            Checkbox(label.name in chosen, onCheckedChange = { on -> if (on) chosen += label.name else chosen -= label.name })

                            LabelChip(label)

                        }

                    }

                }

                is Load.Failed -> Text(l.message)

                Load.Loading -> Text("Loading…")

            }

        },

        confirmButton = {

            TextButton(onClick = {

                vm.setLabels(chosen.toList())

                onDone()

            }) { Text("Save") }

        },

        dismissButton = { TextButton(onClick = onDone) { Text("Cancel") } },

    )

}

/** A new issue's title and description; opened, it shows on its own screen. */

@Composable

fun NewIssueScreen(vm: NewIssueViewModel, onBack: () -> Unit, onOpened: (Long) -> Unit) {

    val working by vm.working.collectAsStateWithLifecycle()

    val error by vm.error.collectAsStateWithLifecycle()

    var title by rememberSaveable { mutableStateOf("") }

    var body by rememberSaveable { mutableStateOf("") }

    AppScreen(title = "New issue", subtitle = "${vm.owner}/${vm.name}", onBack = onBack) {

        Column(Modifier.padding(16.dp).imePadding(), verticalArrangement = Arrangement.spacedBy(12.dp)) {

            OutlinedTextField(title, { title = it }, label = { Text("Title") }, singleLine = true, modifier = Modifier.fillMaxWidth())

            OutlinedTextField(body, { body = it }, label = { Text("Description (Markdown)") }, minLines = 6, modifier = Modifier.fillMaxWidth())

            error?.let { Text(it, color = MaterialTheme.colorScheme.error) }

            Button(enabled = !working && title.isNotBlank(), onClick = { vm.open(title, body) { onOpened(it.number) } }) { Text("Open issue") }

        }

    }

}

package io.oxygenhub.android.ui.issues

import androidx.lifecycle.ViewModel

import androidx.lifecycle.viewModelScope

import io.oxygenhub.android.api.Comment

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.Issue

import io.oxygenhub.android.api.Label

import io.oxygenhub.android.api.userMessage

import io.oxygenhub.android.ui.common.Load

import io.oxygenhub.android.ui.common.load

import kotlinx.coroutines.CancellationException

import kotlinx.coroutines.Job

import kotlinx.coroutines.async

import kotlinx.coroutines.coroutineScope

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow

import kotlinx.coroutines.launch

/**

 * One issue (#4): it and its comments; comment, close or reopen, and set

 * its labels. What the hub refuses is said in [error], and the page stays.

 */

class IssueViewModel(

    private val api: HubApi,

    val owner: String,

    val name: String,

    val number: Long,

) : ViewModel() {

    data class Thread(val issue: Issue, val comments: List<Comment>)

    private val _state = MutableStateFlow<Load<Thread>>(Load.Loading)

    val state: StateFlow<Load<Thread>> = _state.asStateFlow()

    private val _working = MutableStateFlow(false)

    val working: StateFlow<Boolean> = _working.asStateFlow()

    private val _error = MutableStateFlow<String?>(null)

    val error: StateFlow<String?> = _error.asStateFlow()

    /** The repository's labels, once the label picker asks. */

    private val _labels = MutableStateFlow<Load<List<Label>>>(Load.Loading)

    val labels: StateFlow<Load<List<Label>>> = _labels.asStateFlow()

    private var job: Job? = null

    private var labelsJob: Job? = null

    init {

        refresh()

    }

    fun refresh() {

        job = load(_state, job) {

            coroutineScope {

                val issue = async { api.issue(owner, name, number) }

                val comments = async { api.issueComments(owner, name, number) }

                Thread(issue.await(), comments.await())

            }

        }

    }

    fun loadLabels() {

        if (_labels.value is Load.Ready) return

        labelsJob = load(_labels, labelsJob) { api.labels(owner, name) }

    }

    /** Post [body]; true once the hub has it (the box empties then). */

    fun comment(body: String, then: (Boolean) -> Unit = {}) = act({

        val c = api.comment(owner, name, number, body.trim())

        current()?.let { t -> _state.value = Load.Ready(t.copy(comments = t.comments + c, issue = t.issue.copy(comments = t.issue.comments + 1))) }

    }, then)

    fun close(reason: String = "completed") = act({ swap(api.setIssueState(owner, name, number, open = false, reason = reason)) })

    fun reopen() = act({ swap(api.setIssueState(owner, name, number, open = true)) })

    fun setLabels(names: List<String>) = act({ swap(api.setIssueLabels(owner, name, number, names)) })

    fun dismissError() {

        _error.value = null

    }

    private fun current(): Thread? = (_state.value as? Load.Ready)?.value

    private fun swap(issue: Issue) {

        current()?.let { _state.value = Load.Ready(it.copy(issue = issue)) }

    }

    private fun act(step: suspend () -> Unit, then: (Boolean) -> Unit = {}) {

        if (_working.value) return

        _working.value = true

        _error.value = null

        viewModelScope.launch {

            val ok = try {

                step()

                true

            } catch (e: CancellationException) {

                throw e

            } catch (e: Exception) {

                _error.value = e.userMessage()

                false

            } finally {

                _working.value = false

            }

            then(ok)

        }

    }

}

/** A new issue: its title and body, opened on the hub. */

class NewIssueViewModel(

    private val api: HubApi,

    val owner: String,

    val name: String,

) : ViewModel() {

    private val _working = MutableStateFlow(false)

    val working: StateFlow<Boolean> = _working.asStateFlow()

    private val _error = MutableStateFlow<String?>(null)

    val error: StateFlow<String?> = _error.asStateFlow()

    fun open(title: String, body: String, opened: (Issue) -> Unit) {

        if (_working.value || title.isBlank()) return

        _working.value = true

        _error.value = null

        viewModelScope.launch {

            try {

                opened(api.createIssue(owner, name, title.trim(), body.trim()))

            } catch (e: CancellationException) {

                throw e

            } catch (e: Exception) {

                _error.value = e.userMessage()

            } finally {

                _working.value = false

            }

        }

    }

}

package io.oxygenhub.android.ui

import io.oxygenhub.android.FakeHubApi

import io.oxygenhub.android.MainDispatcherRule

import io.oxygenhub.android.api.Comment

import io.oxygenhub.android.api.HubException

import io.oxygenhub.android.api.Issue

import io.oxygenhub.android.ui.common.Load

import io.oxygenhub.android.ui.issues.IssueViewModel

import io.oxygenhub.android.ui.issues.NewIssueViewModel

import org.junit.Assert.assertEquals

import org.junit.Assert.assertFalse

import org.junit.Assert.assertNull

import org.junit.Assert.assertTrue

import org.junit.Rule

import org.junit.Test

class IssueViewModelTest {

    @get:Rule val main = MainDispatcherRule()

    private val api = FakeHubApi().apply {

        issueStore[7] = Issue(7, "Crash on start", "It **crashes**.", author = "bob", comments = 1)

        commentStore[7] = mutableListOf(Comment(1, "bob", "Still happens"))

    }

    private fun thread(vm: IssueViewModel) = (vm.state.value as Load.Ready).value

    @Test

    fun showsTheIssueAndItsComments() {

        val vm = IssueViewModel(api, "andymccall", "demo", 7)

        assertEquals("Crash on start", thread(vm).issue.title)

        assertEquals(listOf("Still happens"), thread(vm).comments.map { it.body })

    }

    @Test

    fun aCommentJoinsTheThreadAndTheBoxEmpties() {

        val vm = IssueViewModel(api, "andymccall", "demo", 7)

        var done: Boolean? = null

        vm.comment("  Fixed in 4f07c5a0  ") { done = it }

        assertEquals(true, done)

        assertEquals(listOf("Still happens", "Fixed in 4f07c5a0"), thread(vm).comments.map { it.body })

        assertEquals(2, thread(vm).issue.comments)

        assertFalse(vm.working.value)

    }

    @Test

    fun closingAndReopeningChangeItsState() {

        val vm = IssueViewModel(api, "andymccall", "demo", 7)

        vm.close("not_planned")

        assertFalse(thread(vm).issue.isOpen)

        assertEquals("not_planned", thread(vm).issue.reason)

        assertTrue("state 7 closed:not_planned" in api.calls)

        vm.reopen()

        assertTrue(thread(vm).issue.isOpen)

    }

    @Test

    fun labelsAreSetAsAWholeSet() {

        val vm = IssueViewModel(api, "andymccall", "demo", 7)

        vm.loadLabels()

        assertEquals(listOf("bug", "ui"), (vm.labels.value as Load.Ready).value.map { it.name })

        vm.setLabels(listOf("bug"))

        assertEquals(listOf("bug"), thread(vm).issue.labels.map { it.name })

    }

    @Test

    fun whatTheHubRefusesIsSaidAndThePageStays() {

        val vm = IssueViewModel(api, "andymccall", "demo", 7)

        api.commentStore.clear()

        val failing = object : io.oxygenhub.android.api.HubApi by api {

            override suspend fun comment(owner: String, name: String, number: Long, body: String): Comment =

                throw HubException.Http(403, "the issue is locked")

        }

        val locked = IssueViewModel(failing, "andymccall", "demo", 7)

        var done: Boolean? = null

        locked.comment("hello") { done = it }

        assertEquals(false, done)

        assertTrue(locked.error.value!!.contains("locked"))

        assertEquals("Crash on start", thread(locked).issue.title)

        locked.dismissError()

        assertNull(locked.error.value)

        assertEquals("Crash on start", thread(vm).issue.title)

    }

    @Test

    fun aNewIssueOpensWithItsTitle() {

        val vm = NewIssueViewModel(api, "andymccall", "demo")

        var opened: Issue? = null

        vm.open("  ", "body") { opened = it }

        assertNull("no title, nothing opened", opened)

        vm.open(" Board grows ", "Done keeps growing") { opened = it }

        assertEquals("Board grows", opened?.title)

        assertEquals(8L, opened?.number)

    }

}

import java.io.IOException

import kotlinx.serialization.json.JsonArray

import kotlinx.serialization.json.JsonObject

import kotlinx.serialization.json.JsonPrimitive

import kotlinx.serialization.json.buildJsonObject

import kotlinx.serialization.json.put

    suspend fun issue(owner: String, name: String, number: Long): Issue

    suspend fun issueComments(owner: String, name: String, number: Long): List<Comment>

    suspend fun comment(owner: String, name: String, number: Long, body: String): Comment

    /** Close (with why: `completed` or `not_planned`) or reopen. */

    suspend fun setIssueState(owner: String, name: String, number: Long, open: Boolean, reason: String = "completed"): Issue

    suspend fun createIssue(owner: String, name: String, title: String, body: String): Issue

    /** The repository's labels, to choose from. */

    suspend fun labels(owner: String, name: String): List<Label>

    /** The issue's whole set of labels (triage). */

    suspend fun setIssueLabels(owner: String, name: String, number: Long, labels: List<String>): Issue

    override suspend fun issue(owner: String, name: String, number: Long): Issue =

        get(url("repos", owner, name, "issues", number.toString()), Issue.serializer())

    override suspend fun issueComments(owner: String, name: String, number: Long): List<Comment> =

        get(url("repos", owner, name, "issues", number.toString(), "comments"), ListSerializer(Comment.serializer()))

    override suspend fun comment(owner: String, name: String, number: Long, body: String): Comment =

        sendJson("POST", url("repos", owner, name, "issues", number.toString(), "comments"), buildJsonObject { put("body", body) }, Comment.serializer())

    override suspend fun setIssueState(owner: String, name: String, number: Long, open: Boolean, reason: String): Issue =

        sendJson(

            "POST",

            url("repos", owner, name, "issues", number.toString()),

            buildJsonObject {

                put("state", if (open) "open" else "closed")

                if (!open) put("reason", reason)

            },

            Issue.serializer(),

        )

    override suspend fun createIssue(owner: String, name: String, title: String, body: String): Issue =

        sendJson("POST", url("repos", owner, name, "issues"), buildJsonObject {

            put("title", title)

            put("body", body)

        }, Issue.serializer())

    override suspend fun labels(owner: String, name: String): List<Label> =

        get(url("repos", owner, name, "labels"), ListSerializer(Label.serializer()))

    override suspend fun setIssueLabels(owner: String, name: String, number: Long, labels: List<String>): Issue =

        sendJson("PATCH", url("repos", owner, name, "issues", number.toString()), buildJsonObject {

            put("labels", JsonArray(labels.map { JsonPrimitive(it) }))

        }, Issue.serializer())

        return try {

            HubJson.decodeFromString(serializer, body)

        } catch (e: IllegalArgumentException) {

            throw HubException.Unreadable("$method ${url.encodedPath}", e)

        }

    }

    /** [json] as the body; the answer read with [serializer]. */

    private suspend fun <T> sendJson(method: String, url: HttpUrl, json: JsonObject, serializer: KSerializer<T>): T {

        val body = call(request(url).method(method, json.toString().toRequestBody(JsonMedia)).build(), notifyUnauthorized = true)

/** A comment on an issue or proposal. */

@Serializable

data class Comment(

    val id: Long = 0,

    val author: String = "",

    val body: String = "",

    @SerialName("created_ms") val createdMs: Long = 0,

)

import androidx.compose.material3.TextButton

 * A repository's issues with their filter, for the repository's tab; an

 * issue opens on its own screen (#4), and [onNewIssue] starts one.

fun IssueList(vm: IssuesViewModel, onOpenIssue: (Long) -> Unit, onNewIssue: (() -> Unit)?) {

            verticalAlignment = Alignment.CenterVertically,

            if (onNewIssue != null) {

                TextButton(onClick = onNewIssue) { Text("New issue") }

            }

                        IssueRow(issue, onClick = { onOpenIssue(issue.number) })

import io.oxygenhub.android.ui.issues.IssueScreen

import io.oxygenhub.android.ui.issues.IssueViewModel

import io.oxygenhub.android.ui.issues.NewIssueScreen

import io.oxygenhub.android.ui.issues.NewIssueViewModel

/** An issue, and a new one (#4). */

@Serializable data class IssueRoute(val owner: String, val name: String, val number: Long)

@Serializable data class NewIssueRoute(val owner: String, val name: String)

                        onOpenIssue = { nav.navigate(IssueRoute(owner, name, it)) },

                        onNewIssue = if (session.canWrite) { { nav.navigate(NewIssueRoute(owner, name)) } } else null,

                    onOpenIssue = { nav.navigate(IssueRoute(r.owner, r.name, it)) },

                    onNewIssue = if (session.canWrite) { { nav.navigate(NewIssueRoute(r.owner, r.name)) } } else null,

                )

            }

            composable<IssueRoute> { e ->

                val r = e.toRoute<IssueRoute>()

                IssueScreen(rememberViewModel { IssueViewModel(api, r.owner, r.name, r.number) }, canWrite = session.canWrite, onBack = { nav.popBackStack() })

            }

            composable<NewIssueRoute> { e ->

                val r = e.toRoute<NewIssueRoute>()

                NewIssueScreen(

                    rememberViewModel { NewIssueViewModel(api, r.owner, r.name) },

                    onBack = { nav.popBackStack() },

                    onOpened = { n -> nav.navigate(IssueRoute(r.owner, r.name, n)) { popUpTo<NewIssueRoute> { inclusive = true } } },

    onOpenIssue: (Long) -> Unit,

    onNewIssue: (() -> Unit)?,

                RepositoryTab.Issues -> IssueList(issues, onOpenIssue, onNewIssue)

    val issueStore = mutableMapOf<Long, io.oxygenhub.android.api.Issue>()

    val commentStore = mutableMapOf<Long, MutableList<io.oxygenhub.android.api.Comment>>()

    var repoLabels = listOf(io.oxygenhub.android.api.Label("bug", "#c62d47"), io.oxygenhub.android.api.Label("ui", "#0969da"))

    override suspend fun issue(owner: String, name: String, number: Long) =

        (issueStore[number] ?: throw io.oxygenhub.android.api.HubException.Http(404, "no such issue")).also { calls += "issue $number" }

    override suspend fun issueComments(owner: String, name: String, number: Long) = commentStore[number].orEmpty().toList()

    override suspend fun comment(owner: String, name: String, number: Long, body: String): io.oxygenhub.android.api.Comment {

        calls += "comment $number"

        val c = io.oxygenhub.android.api.Comment(id = (commentStore.values.sumOf { it.size } + 1).toLong(), author = "andymccall", body = body)

        commentStore.getOrPut(number) { mutableListOf() } += c

        issueStore[number]?.let { issueStore[number] = it.copy(comments = it.comments + 1) }

        return c

    }

    override suspend fun setIssueState(owner: String, name: String, number: Long, open: Boolean, reason: String): io.oxygenhub.android.api.Issue {

        calls += "state $number ${if (open) "open" else "closed:$reason"}"

        val i = issueStore.getValue(number).copy(state = if (open) "open" else "closed", reason = if (open) "" else reason)

        issueStore[number] = i

        return i

    }

    override suspend fun createIssue(owner: String, name: String, title: String, body: String): io.oxygenhub.android.api.Issue {

        val n = (issueStore.keys.maxOrNull() ?: 0) + 1

        val i = io.oxygenhub.android.api.Issue(n, title, body, author = "andymccall")

        issueStore[n] = i

        calls += "create $title"

        return i

    }

    override suspend fun labels(owner: String, name: String) = repoLabels

    override suspend fun setIssueLabels(owner: String, name: String, number: Long, labels: List<String>): io.oxygenhub.android.api.Issue {

        val i = issueStore.getValue(number).copy(labels = repoLabels.filter { it.name in labels })

        issueStore[number] = i

        return i

    }