Approve, reject and expedite from the phone: a job waiting for a person shows Approve and Reject, a live run has Expedite with its reason (refs #5) ca672a3ada1f

- **Approve, reject and expedite runs (#5):** a run's job that waits for a person shows Approve and Reject (its approval rules on the hub decide who may), and a live run has Expedite, which asks why it is urgent (a maintainer's, within the owner's cap). Needs OxygenHub 0.9.11 (the job's `approval` and the expedite route).

    /** Approve, or reject, a job that waits for a person (#5, oxygenflow#57); its approval rules decide who may. */

    suspend fun decideJob(owner: String, name: String, number: Long, job: String, approve: Boolean)

    /** Make a run urgent, saying why (#5, oxygenhub#244): a maintainer's, within the owner's cap. */

    suspend fun expediteRun(owner: String, name: String, number: Long, reason: String)

    }

    override suspend fun decideJob(owner: String, name: String, number: Long, job: String, approve: Boolean) {

        send("POST", url("repos", owner, name, "flow", "runs", number.toString(), "jobs", job, if (approve) "approve" else "reject"))

    }

    override suspend fun expediteRun(owner: String, name: String, number: Long, reason: String) {

        sendJson("POST", url("repos", owner, name, "flow", "runs", number.toString(), "expedite"), buildJsonObject {

            put("reason", reason)

        }, Expedited.serializer())

    /** Its approval gate: `waiting` while it waits for a person, `approved` or `rejected` after (OxygenHub 0.9.11). */

    val approval: String = "",

    /** Queued and waiting for someone to approve or reject it (#5). */

    val waitsForPerson: Boolean get() = status == "queued" && approval == "waiting"

/** What `POST …/flow/runs/N/expedite` answers. */

@Serializable

data class Expedited(val expedited: Boolean = false)

import androidx.compose.material.icons.outlined.Bolt

import androidx.compose.material3.Button

import androidx.compose.material3.OutlinedButton

import androidx.compose.material3.TextButton

import androidx.compose.material3.AlertDialog

import androidx.compose.material3.OutlinedTextField

import androidx.compose.runtime.saveable.rememberSaveable

import androidx.compose.runtime.mutableStateOf

import androidx.compose.runtime.setValue

    var expediting by rememberSaveable { mutableStateOf(false) }

                    IconButton(onClick = { expediting = true }) { Icon(Icons.Outlined.Bolt, contentDescription = "Expedite the run") }

                                // A job that waits for a person (#5): the hub's rules decide who may.

                                if (canWrite && j.waitsForPerson) {

                                    Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {

                                        Button(onClick = { vm.decide(j.name, approve = true) }) { Text("Approve") }

                                        OutlinedButton(onClick = { vm.decide(j.name, approve = false) }) { Text("Reject") }

                                    }

                                }

    if (expediting) {

        ExpediteDialog(onDismiss = { expediting = false }, onExpedite = { reason -> expediting = false; vm.expedite(reason) })

    }

}

/** Make a run urgent, saying why (#5): a maintainer's, within the owner's cap of urgent runs. */

@Composable

private fun ExpediteDialog(onDismiss: () -> Unit, onExpedite: (String) -> Unit) {

    var reason by rememberSaveable { mutableStateOf("") }

    AlertDialog(

        onDismissRequest = onDismiss,

        title = { Text("Expedite") },

        text = {

            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {

                Text("It goes ahead of everyday work until it ends. Say why: it is shown on the run and audited.", style = MaterialTheme.typography.bodySmall)

                OutlinedTextField(value = reason, onValueChange = { reason = it.take(200) }, label = { Text("Why it is urgent") }, singleLine = true)

            }

        },

        confirmButton = { TextButton(onClick = { onExpedite(reason) }, enabled = reason.isNotBlank()) { Text("Expedite") } },

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

    )

    /** Approve, or reject, a job that waits for a person (#5). */

    fun decide(job: String, approve: Boolean) = act { api.decideJob(owner, name, number, job, approve) }

    /** Make the run urgent, saying why (#5). */

    fun expedite(reason: String) = act { api.expediteRun(owner, name, number, reason.trim()) }

    override suspend fun decideJob(owner: String, name: String, number: Long, job: String, approve: Boolean) {

        calls += "${if (approve) "approve" else "reject"} $number $job"

    }

    override suspend fun expediteRun(owner: String, name: String, number: Long, reason: String) {

        calls += "expedite $number $reason"

    }

    fun aGatedJobIsApprovedOrRejectedAndARunExpedited() = runTest {

        val vm = RunViewModel(api, "andymccall", "phone-runner-demo", 56, pollMs = 0)

        vm.decide("deploy", approve = true)

        vm.decide("deploy", approve = false)

        vm.expedite("  the fix for the outage  ")

        assertEquals(listOf("approve 56 deploy", "reject 56 deploy", "expedite 56 the fix for the outage"), api.calls.filter { it.startsWith("approve") || it.startsWith("reject") || it.startsWith("expedite") })

        val gated = io.oxygenhub.android.api.FlowJob("deploy", status = "queued", approval = "waiting")

        assertTrue(gated.waitsForPerson)

        assertTrue(!gated.copy(approval = "approved").waitsForPerson && !gated.copy(status = "running").waitsForPerson)

    }

    @Test