Move Workgroup to a component

src/main/kotlin/component/article/Article.kt

@@ -1,5 +1,9 @@
 package fr.dcproject.component.article
 
+import fr.dcproject.component.workgroup.WorkgroupCart
+import fr.dcproject.component.workgroup.WorkgroupCartI
+import fr.dcproject.component.workgroup.WorkgroupRef
+import fr.dcproject.component.workgroup.WorkgroupSimple
 import fr.dcproject.component.citizen.*
 import fr.dcproject.entity.*
 import fr.postgresjson.entity.*

src/main/kotlin/component/article/routes/UpsertArticle.kt

@@ -6,17 +6,17 @@ import fr.dcproject.component.article.ArticleForUpdate
 import fr.dcproject.component.article.ArticleForView
 import fr.dcproject.component.article.ArticleRepository
 import fr.dcproject.component.article.ArticleVoter
-import fr.dcproject.entity.WorkgroupRef
+import fr.dcproject.component.article.routes.PostArticleRequest.Input
+import fr.dcproject.component.workgroup.WorkgroupRef
 import fr.dcproject.event.ArticleUpdate
 import fr.dcproject.event.raiseEvent
-import fr.dcproject.repository.Workgroup
+import fr.dcproject.component.workgroup.WorkgroupRepository
 import fr.dcproject.voter.assert
 import io.ktor.application.*
 import io.ktor.locations.*
 import io.ktor.request.*
 import io.ktor.response.*
 import io.ktor.routing.*
-import io.ktor.util.pipeline.*
 import java.util.*
 
 @KtorExperimentalLocationsAPI
@@ -36,8 +36,8 @@ class PostArticleRequest {
 }
 
 @KtorExperimentalLocationsAPI
-fun Route.upsertArticle(repo: ArticleRepository, workgroupRepository: Workgroup, voter: ArticleVoter) {
-    suspend fun PipelineContext<Unit, ApplicationCall>.convertDtoToEntity(): ArticleForUpdate = call.receive<PostArticleRequest.Input>().run {
+fun Route.upsertArticle(repo: ArticleRepository, workgroupRepository: WorkgroupRepository, voter: ArticleVoter) {
+    suspend fun ApplicationCall.convertRequestToEntity(): ArticleForUpdate = receive<Input>().run {
         ArticleForUpdate(
             id = id ?: UUID.randomUUID(),
             title = title,
@@ -46,14 +46,14 @@ fun Route.upsertArticle(repo: ArticleRepository, workgroupRepository: Workgroup,
             description = description,
             tags = tags,
             draft = draft,
-            createdBy = call.citizen,
+            createdBy = citizen,
             workgroup = if (workgroup != null) workgroupRepository.findById(workgroup.id) else null,
             versionId = versionId
         )
     }
 
     post<PostArticleRequest> {
-        val article = convertDtoToEntity()
+        val article = call.convertRequestToEntity()
 
         voter.assert { canUpsert(article, citizenOrNull) }
 

src/main/kotlin/component/citizen/Citizen.kt

@@ -4,7 +4,7 @@ import fr.dcproject.component.auth.User
 import fr.dcproject.component.auth.UserI
 import fr.dcproject.component.auth.UserRef
 import fr.dcproject.component.citizen.CitizenI.Name
-import fr.dcproject.entity.WorkgroupSimple
+import fr.dcproject.component.workgroup.WorkgroupSimple
 import fr.postgresjson.entity.*
 import org.joda.time.DateTime
 import java.util.*

src/main/kotlin/component/workgroup/Workgroup.kt

@@ -0,0 +1,107 @@
+package fr.dcproject.component.workgroup
+
+import fr.dcproject.component.auth.UserI
+import fr.dcproject.component.citizen.CitizenBasicI
+import fr.dcproject.component.citizen.CitizenI
+import fr.dcproject.component.citizen.CitizenWithUserI
+import fr.dcproject.component.workgroup.WorkgroupWithMembersI.Member
+import fr.dcproject.component.workgroup.WorkgroupWithMembersI.Member.Role
+import fr.postgresjson.entity.*
+import fr.postgresjson.entity.EntityI
+import java.util.*
+
+@Deprecated("")
+data class Workgroup <C : CitizenBasicI>(
+    override val id: UUID = UUID.randomUUID(),
+    override var name: String,
+    override var description: String,
+    override var logo: String? = null,
+    override var anonymous: Boolean = true,
+    override val createdBy: C,
+    override var members: List<Member<C>> = emptyList()
+) : WorkgroupWithAuthI<C>,
+    WorkgroupSimple<C>(
+        id,
+        name,
+        description,
+        logo,
+        anonymous,
+        createdBy
+    ),
+    EntityCreatedAt by EntityCreatedAtImp(),
+    EntityUpdatedAt by EntityUpdatedAtImp()
+
+@Deprecated("")
+open class WorkgroupSimple<Z : CitizenI>(
+    id: UUID? = null,
+    open var name: String,
+    open var description: String,
+    open var logo: String? = null,
+    open var anonymous: Boolean = true,
+    createdBy: Z
+) : WorkgroupRef(id),
+    EntityCreatedBy<Z> by EntityCreatedByImp(createdBy),
+    EntityDeletedAt by EntityDeletedAtImp()
+
+class WorkgroupCart(
+    override val id: UUID,
+    override val name: String
+) : WorkgroupCartI
+
+interface WorkgroupCartI : UuidEntityI {
+    val name: String
+}
+open class WorkgroupRef(
+    id: UUID? = null
+) : UuidEntity(id ?: UUID.randomUUID()), WorkgroupI
+
+interface WorkgroupWithAuthI<Z : CitizenWithUserI> : WorkgroupWithMembersI<Z>, EntityCreatedBy<Z>, EntityDeletedAt {
+    val anonymous: Boolean
+
+    fun isMember(user: UserI): Boolean = members.isMember(user)
+    fun isMember(citizen: CitizenWithUserI): Boolean = members.isMember(citizen)
+
+    fun hasRole(expectedRole: Role, user: UserI): Boolean = members.hasRole(expectedRole, user)
+    fun hasRole(expectedRole: Role, citizen: CitizenI): Boolean = members.hasRole(expectedRole, citizen)
+
+    fun getRoles(user: UserI): List<Role> = members.getRoles(user)
+    fun getRoles(citizen: CitizenI): List<Role> = members.getRoles(citizen)
+}
+
+interface WorkgroupWithMembersI<Z : CitizenI> : WorkgroupI {
+    var members: List<Member<Z>>
+
+    class Member<C : CitizenI> (
+        val citizen: C,
+        val roles: List<Role> = emptyList()
+    ) : EntityI {
+        enum class Role {
+            MASTER,
+            MANAGER,
+            EDITOR,
+            REPORTER
+        }
+    }
+}
+
+fun List<CitizenI>.hasCitizen(citizen: CitizenI): Boolean = this.map { it.id }.contains(citizen.id)
+
+fun <Z : CitizenWithUserI> List<Member<Z>>.isMember(user: UserI): Boolean =
+    map { it.citizen.user.id }.contains(user.id)
+
+fun <Z : CitizenI> List<Member<Z>>.isMember(citizen: CitizenI): Boolean =
+    map { it.citizen.id }.contains(citizen.id)
+
+fun <Z : CitizenI> List<Member<Z>>.hasRole(expectedRole: Role, citizen: CitizenI): Boolean =
+    any { member -> member.citizen.id == citizen.id && member.roles.any { it == expectedRole } }
+
+fun <Z : CitizenWithUserI> List<Member<Z>>.hasRole(expectedRole: Role, user: UserI): Boolean =
+    any { member -> member.citizen.user.id == user.id && member.roles.any { it == expectedRole } }
+
+fun <Z : CitizenWithUserI> List<Member<Z>>.getRoles(user: UserI): List<Role> =
+    firstOrNull { it.citizen.user.id == user.id }?.roles ?: emptyList()
+
+fun <Z : CitizenWithUserI> List<Member<Z>>.getRoles(citizen: CitizenI): List<Role> =
+    firstOrNull { it.citizen.id == citizen.id }?.roles ?: emptyList()
+
+interface WorkgroupI : UuidEntityI

src/main/kotlin/component/workgroup/WorkgroupRepository.kt

@@ -0,0 +1,95 @@
+package fr.dcproject.component.workgroup
+
+import fr.dcproject.component.citizen.CitizenBasic
+import fr.dcproject.component.citizen.CitizenI
+import fr.dcproject.component.workgroup.WorkgroupWithMembersI.Member
+import fr.postgresjson.connexion.Paginated
+import fr.postgresjson.connexion.Requester
+import fr.postgresjson.entity.Parameter
+import fr.postgresjson.repository.RepositoryI
+import fr.postgresjson.repository.RepositoryI.Direction
+import fr.postgresjson.serializer.serialize
+import net.pearx.kasechange.toSnakeCase
+import java.util.*
+import fr.dcproject.component.workgroup.Workgroup as WorkgroupEntity
+
+class WorkgroupRepository(override var requester: Requester) : RepositoryI {
+    fun findById(id: UUID): WorkgroupEntity<CitizenBasic>? {
+        val function = requester.getFunction("find_workgroup_by_id")
+        return function.selectOne("id" to id)
+    }
+
+    fun find(
+        page: Int = 1,
+        limit: Int = 50,
+        sort: String? = null,
+        direction: Direction? = null,
+        search: String? = null,
+        filter: Filter = Filter()
+    ): Paginated<WorkgroupEntity<CitizenBasic>> {
+        return requester
+            .getFunction("find_workgroups")
+            .select(
+                page, limit,
+                "sort" to sort?.toSnakeCase(),
+                "direction" to direction,
+                "search" to search,
+                "filter" to filter
+            )
+    }
+
+    fun <C : CitizenI, W : WorkgroupSimple<C>> upsert(workgroup: W): WorkgroupEntity<CitizenBasic> = requester
+        .getFunction("upsert_workgroup")
+        .selectOne("resource" to workgroup) ?: error("query 'upsert_workgroup' return null")
+
+    fun <W : WorkgroupRef> delete(workgroup: W) = requester
+            .getFunction("delete_workgroup")
+            .perform("id" to workgroup.id)
+
+    fun addMember(workgroup: WorkgroupI, member: Member<CitizenI>): Member<CitizenBasic>? =
+        addMember(workgroup, member.citizen, member.roles)
+
+    fun addMember(workgroup: WorkgroupI, citizen: CitizenI, roles: List<Member.Role>): Member<CitizenBasic>? = requester
+        .getFunction("add_workgroup_member")
+        .selectOne(
+            "id" to workgroup.id,
+            "members" to Member(citizen, roles).serialize()
+        )
+
+    fun <Z : CitizenI> addMembers(workgroup: WorkgroupI, members: List<Member<Z>>): List<Member<CitizenBasic>> = requester
+        .getFunction("add_workgroup_members")
+        .select(
+            "id" to workgroup.id,
+            "members" to members.serialize()
+        )
+
+    fun <Z : CitizenI> removeMember(workgroup: WorkgroupI, memberToDelete: Member<Z>): List<Member<CitizenBasic>> =
+        removeMembers(workgroup, listOf(memberToDelete))
+
+    fun <Z : CitizenI> removeMembers(workgroup: WorkgroupI, membersToDelete: List<Member<Z>>): List<Member<CitizenBasic>> = requester
+        .getFunction("remove_workgroup_members")
+        .select(
+            "id" to workgroup.id,
+            "members" to membersToDelete
+        )
+
+    fun <Z : CitizenI> updateMembers(workgroup: WorkgroupI, members: List<Member<Z>>): List<Member<CitizenBasic>> = requester
+        .getFunction("update_workgroup_members")
+        .select(
+            "id" to workgroup.id,
+            "members" to members
+        )
+
+    fun <W : WorkgroupWithMembersI<Z>, Z : CitizenI> updateMembers(workgroup: W): W {
+        updateMembers(workgroup, workgroup.members).let {
+            workgroup.members = it as List<Member<Z>>
+        }
+
+        return workgroup
+    }
+
+    class Filter(
+        val createdById: String? = null,
+        val members: List<UUID>? = null
+    ) : Parameter
+}

src/main/kotlin/component/workgroup/routes/CreateWorkgroup.kt

@@ -0,0 +1,49 @@
+package fr.dcproject.component.workgroup.routes
+
+import fr.dcproject.citizen
+import fr.dcproject.component.workgroup.WorkgroupRepository
+import fr.dcproject.component.workgroup.WorkgroupSimple
+import fr.dcproject.component.workgroup.routes.CreateWorkgroup.PostWorkgroupRequest.Input
+import fr.dcproject.security.voter.WorkgroupVoter
+import fr.ktorVoter.assertCan
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.request.*
+import io.ktor.response.*
+import io.ktor.routing.*
+import java.util.*
+
+@KtorExperimentalLocationsAPI
+object CreateWorkgroup {
+    @Location("/workgroups")
+    open class PostWorkgroupRequest {
+        class Input(
+            val id: UUID?,
+            val name: String,
+            val description: String,
+            val logo: String?,
+            val anonymous: Boolean?
+        )
+    }
+
+    fun Route.createWorkgroup(repo: WorkgroupRepository) {
+        post<PostWorkgroupRequest> {
+            call.receive<Input>().run {
+                WorkgroupSimple(
+                    id ?: UUID.randomUUID(),
+                    name,
+                    description,
+                    logo,
+                    anonymous ?: true,
+                    citizen
+                )
+            }.let { workgroup ->
+                assertCan(WorkgroupVoter.Action.CREATE, workgroup)
+                repo.upsert(workgroup)
+            }.let {
+                call.respond(HttpStatusCode.Created, it)
+            }
+        }
+    }
+}

src/main/kotlin/component/workgroup/routes/DeleteWorkgroup.kt

@@ -0,0 +1,27 @@
+package fr.dcproject.component.workgroup.routes
+
+import fr.dcproject.component.workgroup.WorkgroupRepository
+import fr.dcproject.security.voter.WorkgroupVoter
+import fr.ktorVoter.assertCan
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.response.*
+import io.ktor.routing.*
+import java.util.*
+
+@KtorExperimentalLocationsAPI
+object DeleteWorkgroup {
+    @Location("/workgroups/{workgroupId}")
+    class DeleteWorkgroupRequest(val workgroupId: UUID)
+
+    fun Route.deleteWorkgroup(repo: WorkgroupRepository) {
+        delete<DeleteWorkgroupRequest> {
+            repo.findById(it.workgroupId)?.let { workgroup ->
+                assertCan(WorkgroupVoter.Action.DELETE, workgroup)
+                repo.delete(workgroup)
+                call.respond(HttpStatusCode.NoContent)
+            } ?: call.respond(HttpStatusCode.NotFound)
+        }
+    }
+}

src/main/kotlin/component/workgroup/routes/EditWorkgroup.kt

@@ -0,0 +1,46 @@
+package fr.dcproject.component.workgroup.routes
+
+import fr.dcproject.component.workgroup.WorkgroupRepository
+import fr.dcproject.component.workgroup.routes.EditWorkgroup.PutWorkgroupRequest.Input
+import fr.dcproject.security.voter.WorkgroupVoter
+import fr.ktorVoter.assertCan
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.request.*
+import io.ktor.response.*
+import io.ktor.routing.*
+import org.koin.core.KoinComponent
+import java.util.*
+
+@KtorExperimentalLocationsAPI
+object EditWorkgroup {
+    @Location("/workgroups/{workgroupId}")
+    class PutWorkgroupRequest(val workgroupId: UUID) : KoinComponent {
+        class Input(
+            val name: String?,
+            val description: String?,
+            val logo: String?,
+            val anonymous: Boolean?
+        )
+    }
+
+    fun Route.editWorkgroup(repo: WorkgroupRepository) {
+        put<PutWorkgroupRequest> {
+            repo.findById(it.workgroupId)?.let { old ->
+                call.receive<Input>().run {
+                    old.copy(
+                        name = name ?: old.name,
+                        description = description ?: old.description,
+                        logo = logo ?: old.logo,
+                        anonymous = anonymous ?: old.anonymous
+                    ).let { workgroup ->
+                        assertCan(WorkgroupVoter.Action.UPDATE, workgroup)
+                        repo.upsert(workgroup)
+                        call.respond(HttpStatusCode.OK, it)
+                    }
+                }
+            } ?: call.respond(HttpStatusCode.NotFound)
+        }
+    }
+}

src/main/kotlin/component/workgroup/routes/GetWorkgroup.kt

@@ -0,0 +1,26 @@
+package fr.dcproject.component.workgroup.routes
+
+import fr.dcproject.component.workgroup.WorkgroupRepository
+import fr.dcproject.security.voter.WorkgroupVoter
+import fr.ktorVoter.assertCan
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.response.*
+import io.ktor.routing.*
+import java.util.*
+
+@KtorExperimentalLocationsAPI
+object GetWorkgroup {
+    @Location("/workgroups/{workgroupId}")
+    class WorkgroupRequest(val workgroupId: UUID)
+
+    fun Route.getWorkgroup(repo: WorkgroupRepository) {
+        get<WorkgroupRequest> {
+            repo.findById(it.workgroupId)?.let { workgroup ->
+                assertCan(WorkgroupVoter.Action.VIEW, workgroup)
+                call.respond(workgroup)
+            } ?: call.respond(HttpStatusCode.NotFound)
+        }
+    }
+}

src/main/kotlin/component/workgroup/routes/GetWorkgroups.kt

@@ -0,0 +1,41 @@
+package fr.dcproject.component.workgroup.routes
+
+import fr.dcproject.component.workgroup.WorkgroupRepository
+import fr.dcproject.security.voter.WorkgroupVoter
+import fr.dcproject.utils.toUUID
+import fr.ktorVoter.assertCanAll
+import fr.postgresjson.repository.RepositoryI
+import io.ktor.application.*
+import io.ktor.locations.*
+import io.ktor.response.*
+import io.ktor.routing.*
+import java.util.*
+
+@KtorExperimentalLocationsAPI
+object GetWorkgroups {
+    @Location("/workgroups")
+    class WorkgroupsRequest(
+        page: Int = 1,
+        limit: Int = 50,
+        val sort: String? = null,
+        val direction: RepositoryI.Direction? = null,
+        val search: String? = null,
+        val createdBy: String? = null,
+        members: List<String?>? = null
+    ) {
+        val page: Int = if (page < 1) 1 else page
+        val limit: Int = if (limit > 50) 50 else if (limit < 1) 1 else limit
+        val members: List<UUID>? = members?.toUUID()
+    }
+
+    fun Route.getWorkgroups(repo: WorkgroupRepository) {
+        get<WorkgroupsRequest> {
+            val workgroups =
+                repo.find(it.page, it.limit, it.sort, it.direction, it.search,
+                    WorkgroupRepository.Filter(createdById = it.createdBy, members = it.members)
+                )
+            assertCanAll(WorkgroupVoter.Action.VIEW, workgroups.result)
+            call.respond(workgroups)
+        }
+    }
+}

src/main/kotlin/component/workgroup/routes/members/AddMemberToWorkgroup.kt

@@ -0,0 +1,52 @@
+package fr.dcproject.component.workgroup.routes.members
+
+import fr.dcproject.component.citizen.CitizenRef
+import fr.dcproject.component.workgroup.WorkgroupRepository
+import fr.dcproject.component.workgroup.WorkgroupWithMembersI
+import fr.dcproject.security.voter.WorkgroupVoter
+import fr.ktorVoter.assertCan
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.request.*
+import io.ktor.response.*
+import io.ktor.routing.*
+import org.koin.core.KoinComponent
+import java.util.*
+
+@KtorExperimentalLocationsAPI
+object AddMemberToWorkgroup {
+    @Location("/workgroups/{workgroupId}/members")
+    class WorkgroupsMembersRequest(val workgroupId: UUID) : KoinComponent {
+        class Input : MutableList<Input.Item> by mutableListOf() {
+            class Item(val citizen: CitizenRef, roles: List<String> = emptyList()) {
+                val roles: List<WorkgroupWithMembersI.Member.Role> = roles.map {
+                    WorkgroupWithMembersI.Member.Role.valueOf(it)
+                }
+            }
+        }
+    }
+
+    @KtorExperimentalLocationsAPI
+    private suspend fun ApplicationCall.getMembersFromRequest(): List<WorkgroupWithMembersI.Member<CitizenRef>> = receive<WorkgroupsMembersRequest.Input>().map {
+        WorkgroupWithMembersI.Member(
+            citizen = it.citizen,
+            roles = it.roles
+        )
+    }
+
+    @KtorExperimentalLocationsAPI
+    fun Route.addMemberToWorkgroup(repo: WorkgroupRepository) {
+        /* Add members to workgroup */
+        post<WorkgroupsMembersRequest> {
+            repo.findById(it.workgroupId)?.let { workgroup ->
+                call.getMembersFromRequest().let { members ->
+                    assertCan(WorkgroupVoter.ActionMembers.ADD, workgroup)
+                    repo.addMembers(workgroup, members)
+                }.let { members ->
+                    call.respond(HttpStatusCode.Created, members)
+                }
+            } ?: call.respond(HttpStatusCode.NotFound)
+        }
+    }
+}

src/main/kotlin/component/workgroup/routes/members/DeleteMembersOfWorkgroup.kt

@@ -0,0 +1,50 @@
+package fr.dcproject.component.workgroup.routes.members
+
+import fr.dcproject.component.citizen.CitizenRef
+import fr.dcproject.component.workgroup.WorkgroupRepository
+import fr.dcproject.component.workgroup.WorkgroupWithMembersI
+import fr.dcproject.security.voter.WorkgroupVoter
+import fr.ktorVoter.assertCan
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.request.*
+import io.ktor.response.*
+import io.ktor.routing.*
+import org.koin.core.KoinComponent
+import java.util.*
+
+@KtorExperimentalLocationsAPI
+object DeleteMembersOfWorkgroup {
+    @Location("/workgroups/{workgroupId}/members")
+    class WorkgroupsMembersRequest(val workgroupId: UUID) : KoinComponent {
+        class Input : MutableList<Input.Item> by mutableListOf() {
+            class Item(val citizen: CitizenRef, roles: List<String> = emptyList()) {
+                val roles: List<WorkgroupWithMembersI.Member.Role> = roles.map {
+                    WorkgroupWithMembersI.Member.Role.valueOf(it)
+                }
+            }
+        }
+    }
+
+    private suspend fun ApplicationCall.getMembersFromRequest(): List<WorkgroupWithMembersI.Member<CitizenRef>> = receive<WorkgroupsMembersRequest.Input>().map {
+        WorkgroupWithMembersI.Member(
+            citizen = it.citizen,
+            roles = it.roles
+        )
+    }
+
+    fun Route.deleteMemberOfWorkgroup(repo: WorkgroupRepository) {
+        /* Delete members of workgroup */
+        delete<WorkgroupsMembersRequest> {
+            repo.findById(it.workgroupId)?.let { workgroup ->
+                call.getMembersFromRequest().let { members ->
+                        assertCan(WorkgroupVoter.ActionMembers.REMOVE, workgroup)
+                        repo.removeMembers(workgroup, members)
+                    }.let { members ->
+                        call.respond(HttpStatusCode.OK, members)
+                    }
+            } ?: call.respond(HttpStatusCode.NotFound)
+        }
+    }
+}

src/main/kotlin/component/workgroup/routes/members/UpdateMemberOfWorkgroup.kt

@@ -0,0 +1,50 @@
+package fr.dcproject.component.workgroup.routes.members
+
+import fr.dcproject.component.citizen.CitizenRef
+import fr.dcproject.component.workgroup.WorkgroupRepository
+import fr.dcproject.component.workgroup.WorkgroupWithMembersI
+import fr.dcproject.security.voter.WorkgroupVoter
+import fr.ktorVoter.assertCan
+import io.ktor.application.*
+import io.ktor.http.*
+import io.ktor.locations.*
+import io.ktor.request.*
+import io.ktor.response.*
+import io.ktor.routing.*
+import org.koin.core.KoinComponent
+import java.util.*
+
+@KtorExperimentalLocationsAPI
+object UpdateMemberOfWorkgroup {
+    @Location("/workgroups/{workgroupId}/members")
+    class WorkgroupsMembersRequest(val workgroupId: UUID) : KoinComponent {
+        class Input : MutableList<Input.Item> by mutableListOf() {
+            class Item(val citizen: CitizenRef, roles: List<String> = emptyList()) {
+                val roles: List<WorkgroupWithMembersI.Member.Role> = roles.map {
+                    WorkgroupWithMembersI.Member.Role.valueOf(it)
+                }
+            }
+        }
+    }
+
+    private suspend fun ApplicationCall.getMembersFromRequest(): List<WorkgroupWithMembersI.Member<CitizenRef>> = receive<WorkgroupsMembersRequest.Input>().map {
+        WorkgroupWithMembersI.Member(
+            citizen = it.citizen,
+            roles = it.roles
+        )
+    }
+
+    fun Route.updateMemberOfWorkgroup(repo: WorkgroupRepository) {
+        /* Update members of workgroup */
+        put<WorkgroupsMembersRequest> {
+            repo.findById(it.workgroupId)?.let { workgroup ->
+                call.getMembersFromRequest().let { members ->
+                        assertCan(WorkgroupVoter.ActionMembers.UPDATE, workgroup)
+                        repo.updateMembers(workgroup, members)
+                    }.let { members ->
+                        call.respond(HttpStatusCode.OK, members)
+                    }
+            } ?: call.respond(HttpStatusCode.NotFound)
+        }
+    }
+}