Account and organisation pages 62429abe5869

package io.oxygenhub.android.ui.owners

import androidx.compose.foundation.clickable

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.fillMaxSize

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.outlined.Lock

import androidx.compose.material.icons.outlined.ViewKanban

import androidx.compose.material3.AssistChip

import androidx.compose.material3.HorizontalDivider

import androidx.compose.material3.Icon

import androidx.compose.material3.ListItem

import androidx.compose.material3.MaterialTheme

import androidx.compose.material3.Text

import androidx.compose.runtime.Composable

import androidx.compose.runtime.getValue

import androidx.compose.ui.Alignment

import androidx.compose.ui.Modifier

import androidx.compose.ui.unit.dp

import androidx.lifecycle.ViewModel

import androidx.lifecycle.compose.collectAsStateWithLifecycle

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.HubException

import io.oxygenhub.android.api.Owner

import io.oxygenhub.android.api.Project

import io.oxygenhub.android.api.Repository

import io.oxygenhub.android.api.Visibility

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

import io.oxygenhub.android.ui.common.AvatarImage

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

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

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

import io.oxygenhub.android.ui.common.rememberAvatar

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

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

/** An owner's page: who they are, their repositories (those you can read) and boards. */

data class OwnerPage(val owner: Owner, val repositories: List<Repository>, val projects: List<Project>)

/** An account's or organisation's page; a name is tried as an account, then as an organisation. */

class OwnerViewModel(private val api: HubApi, val name: String) : ViewModel() {

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

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

    private var job: Job? = null

    init {

        refresh()

    }

    fun refresh() {

        job = load(_state, job) {

            coroutineScope {

                val repos = async { api.repositories().filter { it.owner.equals(name, ignoreCase = true) }.sortedByDescending { it.updatedMs } }

                val projects = async { runCatching { api.projects(name) }.getOrDefault(emptyList()).filter { !it.closed } }

                val owner = try {

                    Owner.Person(api.account(name))

                } catch (e: HubException.Http) {

                    if (e.status != 404) throw e

                    Owner.Org(api.organisation(name))

                }

                OwnerPage(owner, repos.await(), projects.await())

            }

        }

    }

}

@OptIn(ExperimentalLayoutApi::class)

@Composable

fun OwnerScreen(

    vm: OwnerViewModel,

    api: HubApi,

    onBack: () -> Unit,

    onOpenOwner: (String) -> Unit,

    onOpenRepository: (Repository) -> Unit,

    onOpenProject: (Project) -> Unit,

) {

    val state by vm.state.collectAsStateWithLifecycle()

    AppScreen(title = vm.name, onBack = onBack) {

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

            LazyColumn(Modifier.fillMaxSize()) {

                item {

                    Row(Modifier.padding(16.dp), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(16.dp)) {

                        AvatarImage(rememberAvatar(api, page.owner.name), page.owner.name, size = 64.dp)

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

                            Text(page.owner.shownName, style = MaterialTheme.typography.titleLarge)

                            Text(

                                when (val o = page.owner) {

                                    is Owner.Person -> listOfNotNull(

                                        o.user.username.takeIf { it != o.shownName },

                                        "joined ${relativeTime(o.user.createdMs)}".takeIf { o.user.createdMs > 0 },

                                    ).joinToString(" · ")

                                    is Owner.Org -> "organisation · ${o.org.members.size} ${if (o.org.members.size == 1) "member" else "members"}"

                                },

                                style = MaterialTheme.typography.bodyMedium,

                                color = MaterialTheme.colorScheme.onSurfaceVariant,

                            )

                        }

                    }

                    (page.owner as? Owner.Org)?.let { o ->

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

                            if (o.org.description.isNotBlank()) Text(o.org.description, style = MaterialTheme.typography.bodyMedium)

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

                                o.org.members.forEach { m ->

                                    AssistChip(

                                        onClick = { onOpenOwner(m) },

                                        label = { Text(m) },

                                        leadingIcon = { AvatarImage(rememberAvatar(api, m), m, size = 18.dp) },

                                    )

                                }

                            }

                        }

                    }

                }

                if (page.projects.isNotEmpty()) {

                    item { Section("Projects") }

                    items(page.projects, key = { "p${it.number}" }) { p ->

                        ListItem(

                            modifier = Modifier.clickable { onOpenProject(p) },

                            leadingContent = { Icon(Icons.Outlined.ViewKanban, contentDescription = null) },

                            headlineContent = { Text(p.title.ifBlank { "Project ${p.number}" }) },

                            supportingContent = if (p.description.isNotBlank()) {

                                { Text(p.description, maxLines = 2) }

                            } else {

                                null

                            },

                        )

                    }

                }

                item { Section(if (page.repositories.isEmpty()) "No repositories you can read" else "Repositories") }

                items(page.repositories, key = { it.slug }) { r ->

                    ListItem(

                        modifier = Modifier.clickable { onOpenRepository(r) },

                        headlineContent = { Text(r.name) },

                        supportingContent = {

                            Text(

                                listOfNotNull(r.description.takeIf { it.isNotBlank() }, "updated ${relativeTime(r.updatedMs)}".takeIf { r.updatedMs > 0 })

                                    .joinToString(" · "),

                                maxLines = 2,

                            )

                        },

                        trailingContent = if (r.visibility != Visibility.Public) {

                            { Icon(Icons.Outlined.Lock, contentDescription = "Not public") }

                        } else {

                            null

                        },

                    )

                    HorizontalDivider()

                }

            }

        }

    }

}

@Composable

private fun Section(title: String) {

    Text(

        title,

        modifier = Modifier.padding(start = 16.dp, end = 16.dp, top = 20.dp, bottom = 4.dp),

        style = MaterialTheme.typography.titleSmall,

        color = MaterialTheme.colorScheme.primary,

    )

}

package io.oxygenhub.android.ui

import io.oxygenhub.android.FakeHubApi

import io.oxygenhub.android.MainDispatcherRule

import io.oxygenhub.android.api.HubException

import io.oxygenhub.android.api.Organisation

import io.oxygenhub.android.api.Owner

import io.oxygenhub.android.api.Repository

import io.oxygenhub.android.api.User

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

import io.oxygenhub.android.ui.owners.OwnerViewModel

import org.junit.Assert.assertEquals

import org.junit.Assert.assertTrue

import org.junit.Rule

import org.junit.Test

class OwnerViewModelTest {

    @get:Rule val main = MainDispatcherRule()

    private val api = FakeHubApi().apply {

        repositories = {

            listOf(

                Repository("doomsdayone", "tetris", updatedMs = 1),

                Repository("andymccall", "oxygen", updatedMs = 5),

                Repository("doomsdayone", "supermarioland2", updatedMs = 9),

            )

        }

    }

    @Test

    fun aNameIsAnAccountOrElseAnOrganisation() {

        api.accounts = mapOf("andymccall" to User("andymccall", displayName = "Andy McCall"))

        api.orgs = mapOf("doomsdayone" to Organisation("doomsdayone", "Doomsday One", members = listOf("andymccall")))

        val andy = (OwnerViewModel(api, "andymccall").state.value as Load.Ready).value

        assertEquals("Andy McCall", andy.owner.shownName)

        assertEquals(listOf("oxygen"), andy.repositories.map { it.name })

        val org = (OwnerViewModel(api, "doomsdayone").state.value as Load.Ready).value

        assertTrue(org.owner is Owner.Org)

        assertEquals(listOf("andymccall"), (org.owner as Owner.Org).org.members)

        assertEquals(listOf("supermarioland2", "tetris"), org.repositories.map { it.name })

        assertTrue("asked as an organisation once no account has the name", "org doomsdayone" in api.calls)

    }

    @Test

    fun neitherIsAFailure() {

        assertTrue(OwnerViewModel(api, "nobody").state.value is Load.Failed)

    }

}

- **Account and organisation pages:** an owner's page shows who they are (avatar, name, when they joined; an organisation's description and members, each opening their own page), their open project boards and the repositories of theirs you can read, newest first. Opened from a repository's top bar, from a member, and from hub links to `/{owner}` or `/orgs/{name}`. From `GET /users/{name}`, else `GET /orgs/{name}`.

    /** An account's public profile, and an organisation's (with its members). */

    suspend fun account(name: String): User

    suspend fun organisation(name: String): Organisation

    override suspend fun account(name: String): User = get(url("users", name), User.serializer())

    override suspend fun organisation(name: String): Organisation = get(url("orgs", name), Organisation.serializer())

/** An organisation (`GET /orgs/{name}`). */

@Serializable

data class Organisation(

    val name: String,

    @SerialName("display_name") val displayName: String = "",

    val description: String = "",

    val members: List<String> = emptyList(),

)

/** An account or an organisation, as its page shows it. */

sealed interface Owner {

    val name: String

    val shownName: String

    data class Person(val user: User) : Owner {

        override val name get() = user.username

        override val shownName get() = user.shownName

    }

    data class Org(val org: Organisation) : Owner {

        override val name get() = org.name

        override val shownName get() = org.displayName.ifBlank { org.name }

    }

}

import io.oxygenhub.android.ui.owners.OwnerScreen

import io.oxygenhub.android.ui.owners.OwnerViewModel

/** An account's or organisation's page. */

@Serializable data class OwnerRoute(val name: String)

                        onOpenOwner = { nav.navigate(OwnerRoute(owner)) },

                    onOpenOwner = { nav.navigate(OwnerRoute(r.owner)) },

                )

            }

            composable<OwnerRoute> { e ->

                val r = e.toRoute<OwnerRoute>()

                OwnerScreen(

                    rememberViewModel { OwnerViewModel(api, r.name) },

                    api,

                    onBack = { nav.popBackStack() },

                    onOpenOwner = { nav.navigate(OwnerRoute(it)) },

                    onOpenRepository = { nav.navigate(IssuesRoute(it.owner, it.name)) },

                    onOpenProject = { nav.navigate(BoardRoute(it.owner, it.number)) },

 * file, history, board, repository, account or organisation. Null for a page the app does not

    if (parts.size == 2 && parts[0] == "orgs") return OwnerRoute(parts[1])

    if (parts.size == 1 && parts[0] !in HUB_PAGES) return OwnerRoute(parts[0])

import androidx.compose.material3.IconButton

import androidx.compose.material3.Icon

import androidx.compose.material.icons.Icons

import androidx.compose.material.icons.outlined.AccountCircle

    onOpenOwner: (() -> Unit)? = null,

    AppScreen(

        title = "${issues.owner}/${issues.name}",

        onBack = onBack,

        actions = {

            onOpenOwner?.let { open ->

                IconButton(onClick = open) { Icon(Icons.Outlined.AccountCircle, contentDescription = "${issues.owner}'s page") }

            }

        },

    ) {

import io.oxygenhub.android.api.HubException

    var accounts: Map<String, io.oxygenhub.android.api.User> = emptyMap()

    var orgs: Map<String, io.oxygenhub.android.api.Organisation> = emptyMap()

    override suspend fun account(name: String) =

        (accounts[name] ?: throw HubException.Http(404, "no such account")).also { calls += "account $name" }

    override suspend fun organisation(name: String) =

        (orgs[name] ?: throw HubException.Http(404, "no such organisation")).also { calls += "org $name" }

import io.oxygenhub.android.ui.nav.OwnerRoute

        assertEquals(OwnerRoute("andymccall"), r("/andymccall"))

        assertEquals(OwnerRoute("doomsdayone"), r("/orgs/doomsdayone"))

        assertNull("a hub page, not an owner", r("/explore"))