Refactors Articles and Voter

- Move files into components (article)
- Split articles routes
- Refactoring for remove ktor-voter (ArticleVoter)
- Remove mutability
- Move DataConversion to separate file (Converter.kt)
- Add Schemas for Articles routes
- Fix SQL Query for Workgroup roles
- rename container_name in docker-compose

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

@@ -0,0 +1,126 @@
+package fr.dcproject.component.article
+
+import fr.dcproject.entity.*
+import fr.postgresjson.entity.*
+import org.joda.time.DateTime
+import java.util.*
+
+data class ArticleForView (
+    override val id: UUID = UUID.randomUUID(),
+    override val title: String,
+    val anonymous: Boolean = true,
+    val content: String,
+    val description: String,
+    val tags: List<String> = emptyList(),
+    override val createdBy: CitizenRef,
+    override val versionNumber: Int = 0,
+    override val versionId: UUID = UUID.randomUUID(),
+    val workgroup: WorkgroupSimple<CitizenRef>? = null,
+    override val opinions: Opinions = emptyMap(),
+    override val draft: Boolean = false,
+    override val deletedAt: DateTime? = null
+) : ArticleRef(id),
+    ArticleAuthI<CitizenRef>,
+    ArticleWithTitleI,
+    EntityVersioning<UUID, Int>,
+    EntityCreatedAt by EntityCreatedAtImp(),
+    EntityDeletedAt by EntityDeletedAtImp(deletedAt),
+    ArticleRefVersioningI,
+    Opinionable,
+    Votable by VotableImp() {
+    val lastVersion: Boolean = false
+}
+
+interface ArticleForUpdateI<C: CitizenRef> : ArticleI, ArticleWithTitleI, VersionableRef, TargetI, CreatedBy<C> {
+    val anonymous: Boolean
+    val content: String
+    val description: String
+    val draft: Boolean
+    val workgroup: WorkgroupRef?
+}
+
+class ArticleForUpdate (
+    id: UUID? = null,
+    override val title: String,
+    override val anonymous: Boolean = true,
+    override val content: String,
+    override val description: String,
+    tags: List<String> = emptyList(),
+    override val draft: Boolean = false,
+    override val createdBy: CitizenRef,
+    override val workgroup: WorkgroupRef? = null,
+    versionId: UUID? = null,
+    override val deletedAt: DateTime? = null
+) : ArticleForUpdateI<CitizenRef>,
+    ArticleAuthI<CitizenRef>,
+    ArticleRefVersioningI by ArticleRefVersioningImmutable(id, versionId = versionId ?: UUID.randomUUID()) {
+    val tags: List<String> = tags.distinct()
+    val isNew = versionId == null
+}
+
+@Deprecated("")
+open class ArticleSimple(
+    id: UUID = UUID.randomUUID(),
+    var title: String,
+    override val createdBy: CitizenBasic,
+    override var draft: Boolean = false,
+    var workgroup: WorkgroupSimple<CitizenRef>? = null
+) : ArticleAuthI<CitizenBasicI>,
+    ArticleRefVersioning(id),
+    EntityCreatedAt by EntityCreatedAtImp(),
+    CreatedBy<CitizenBasicI> by CreatedByImp(createdBy),
+    EntityDeletedAt by EntityDeletedAtImp(),
+    Votable by VotableImp(),
+    Opinionable by OpinionableImp()
+
+class ArticleForListing(
+    id: UUID? = null,
+    override val title: String,
+    override val createdBy: CitizenCart,
+    override val workgroup: WorkgroupCart?,
+    override val deletedAt: DateTime?,
+    override val draft: Boolean
+) : ArticleForListingI,
+    ArticleRef(id),
+    ArticleAuthI<CitizenCartI>,
+    Votable by VotableImp(),
+    CreatedBy<CitizenCartI>
+
+interface ArticleForListingI : ArticleWithTitleI, CreatedBy<CitizenCartI> {
+    val workgroup: WorkgroupCartI?
+}
+
+@Deprecated("", ReplaceWith("ArticleRefVersioningImmutable"))
+open class ArticleRefVersioning(
+    id: UUID = UUID.randomUUID(),
+    override var versionNumber: Int = 0,
+    versionId: UUID = UUID.randomUUID()
+) : ArticleRefVersioningI,
+    ArticleRef(id),
+    EntityVersioning<UUID, Int> by UuidEntityVersioning(versionNumber, versionId)
+
+open class ArticleRefVersioningImmutable(
+    id: UUID? = null,
+    versionId: UUID = UUID.randomUUID()
+) : ArticleRefVersioningI,
+    ArticleRef(id),
+    VersionableRef by VersionableRefImp(versionId)
+
+interface ArticleRefVersioningI : ArticleI, VersionableRef
+
+open class ArticleRef(
+    id: UUID? = null
+) : ArticleI, TargetRef(id)
+
+interface ArticleI : UuidEntityI, TargetI
+
+interface ArticleWithTitleI : ArticleI {
+    val title: String
+}
+
+interface ArticleAuthI<U : CitizenI> :
+    ArticleI,
+    CreatedBy<U>,
+    EntityDeletedAt {
+    val draft: Boolean
+}

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

@@ -0,0 +1,51 @@
+package fr.dcproject.component.article
+
+import fr.postgresjson.connexion.Paginated
+import fr.postgresjson.connexion.Requester
+import fr.postgresjson.entity.Parameter
+import fr.postgresjson.repository.RepositoryI
+import net.pearx.kasechange.toSnakeCase
+import java.util.*
+
+class ArticleRepository(override var requester: Requester) : RepositoryI {
+    fun findById(id: UUID): ArticleForView? {
+        val function = requester.getFunction("find_article_by_id")
+        return function.selectOne("id" to id)
+    }
+
+    fun findVersionsByVersionId(page: Int = 1, limit: Int = 50, versionId: UUID): Paginated<ArticleForView> {
+        return requester
+            .getFunction("find_articles_versions_by_version_id")
+            .select(page, limit, "version_id" to versionId)
+    }
+
+    fun find(
+        page: Int = 1,
+        limit: Int = 50,
+        sort: String? = null,
+        direction: RepositoryI.Direction? = null,
+        search: String? = null,
+        filter: Filter = Filter()
+    ): Paginated<ArticleForListing> {
+        return requester
+            .getFunction("find_articles")
+            .select(
+                page, limit,
+                "sort" to sort?.toSnakeCase(),
+                "direction" to direction,
+                "search" to search,
+                "filter" to filter
+            )
+    }
+
+    fun upsert(article: ArticleForUpdate): ArticleForView? {
+        return requester
+            .getFunction("upsert_article")
+            .selectOne("resource" to article)
+    }
+
+    class Filter(
+        val createdById: String? = null,
+        val workgroupId: String? = null
+    ) : Parameter
+}

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

@@ -0,0 +1,95 @@
+package fr.dcproject.component.article
+
+import fr.dcproject.entity.CitizenI
+import fr.dcproject.entity.ViewAggregation
+import fr.dcproject.utils.contentToString
+import fr.dcproject.utils.getJsonField
+import fr.dcproject.utils.toIso
+import fr.dcproject.views.ViewManager
+import org.elasticsearch.client.Request
+import org.elasticsearch.client.Response
+import org.elasticsearch.client.RestClient
+import org.joda.time.DateTime
+import java.util.*
+
+/**
+ * Wrapper for manage views with elasticsearch
+ */
+class ArticleViewManager(private val restClient: RestClient) : ViewManager<ArticleRefVersioningI> {
+    /**
+     * Add view on article to elasticsearch
+     */
+    override fun addView(ip: String, article: ArticleRefVersioningI, citizen: CitizenI?, dateTime: DateTime): Response? {
+        val isLogged = (citizen != null).toString()
+        val ref = citizen?.id ?: UUID.nameUUIDFromBytes(ip.toByteArray())!!
+        val request = Request(
+            "POST",
+            "/views/_doc/"
+        ).apply {
+            //language=JSON
+            setJsonEntity("""
+                {
+                  "logged": $isLogged,
+                  "type": "article",
+                  "user_ref": "$ref",
+                  "ip": "$ip",
+                  "id": "${article.id}",
+                  "version_id": "${article.versionId}",
+                  "citizen_id": "${citizen?.id}",
+                  "view_at": "${dateTime.toIso()}"
+                }
+            """.trimIndent())
+        }
+
+        return restClient.performRequest(request)
+    }
+
+    /**
+     * Get article views aggregations from elasticsearch
+     */
+    override fun getViewsCount(article: ArticleRefVersioningI): ViewAggregation {
+        val request = Request(
+            "GET",
+            "/views/_search"
+        ).apply {
+            //language=JSON
+            setJsonEntity("""
+            {
+              "size": 0,
+              "query": {
+                "bool": {
+                  "must": {
+                    "term": {
+                      "version_id": "${article.versionId}"
+                    }
+                  }
+                }
+              },
+              "aggs" : {
+                "total": {
+                  "composite" : {
+                    "sources" : [
+                      { "version_id": { "terms": {"field": "version_id" } } }
+                    ]
+                  }
+                },
+                "unique" : {
+                  "cardinality" : {
+                    "field" : "user_ref",
+                    "precision_threshold": 1
+                  }
+                }
+              }
+            }
+            """.trimIndent())
+        }
+
+        return restClient
+            .performRequest(request).contentToString().run {
+                ViewAggregation(
+                    getJsonField("$.aggregations.total.buckets[0].doc_count") ?: 0,
+                    getJsonField("$.aggregations.unique.value") ?: 0
+                )
+            }
+    }
+}

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

@@ -0,0 +1,49 @@
+package fr.dcproject.component.article
+
+import fr.dcproject.entity.CitizenI
+import fr.dcproject.entity.CreatedBy
+import fr.dcproject.entity.VersionableRef
+import fr.dcproject.voter.Voter
+import fr.dcproject.voter.VoterResponse
+
+class ArticleVoter(private val articleRepo: ArticleRepository): Voter() {
+    fun <S: ArticleAuthI<*>> canView(subjects: List<S>, citizen: CitizenI?): VoterResponse =
+        canAll(subjects) { canView(it, citizen) }
+
+    fun <S: ArticleAuthI<*>> canView(subject: S, citizen: CitizenI?): VoterResponse {
+        return if (subject.isDeleted()) denied("Article is deleted", "article.deleted")
+        else if (subject.draft && (citizen == null || subject.createdBy.id != citizen.id)) denied("Article is draft, but it's not yours", "article.draft.not.yours")
+        else granted()
+    }
+
+    fun <S: CreatedBy<*>> canDelete(subject: S, citizen: CitizenI?): VoterResponse {
+        if (citizen == null) return denied("You must be connected to create article", "article.create.notConnected")
+        return if (subject.createdBy.id == citizen.id) {
+            granted()
+        } else {
+            denied("Cannot delete article if is not yours", "article.delete.notYours")
+        }
+    }
+
+    fun <S> canUpsert(subject: S, citizen: CitizenI?): VoterResponse
+        where S: ArticleI,
+              S: CreatedBy<*>,
+              S: VersionableRef {
+        if (citizen == null) return denied("You must be connected to create article", "article.create.notConnected")
+        /* The new Article must by created by the same citizen of the connected citizen */
+        if (subject.createdBy.id == citizen.id) {
+            /* The creator must be the same of the creator of preview version of article */
+                val lastVersionId = articleRepo
+                    .findVersionsByVersionId(1, 1, subject.versionId)
+                    .result
+                    .firstOrNull()?.createdBy?.id
+
+            return when (lastVersionId) {
+                null -> granted("You can create a new Article")
+                citizen.id -> granted("Last version is yours")
+                else -> denied("Last version is not yours", "article.lastVersion.notYours")
+            }
+        }
+        return denied("This article must be yours for update it", "article.update.notYours")
+    }
+}

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

@@ -0,0 +1,39 @@
+package fr.dcproject.component.article.route
+
+import fr.dcproject.citizenOrNull
+import fr.dcproject.component.article.ArticleForView
+import fr.dcproject.component.article.ArticleRepository
+import fr.dcproject.component.article.ArticleVoter
+import fr.dcproject.voter.assert
+import fr.postgresjson.repository.RepositoryI
+import io.ktor.application.*
+import io.ktor.locations.*
+import io.ktor.response.*
+import io.ktor.routing.*
+
+@KtorExperimentalLocationsAPI
+@Location("/articles/{article}/versions")
+class ArticleVersionsRequest(
+    val article: ArticleForView,
+    page: Int = 1,
+    limit: Int = 50,
+    val sort: String? = null,
+    val direction: RepositoryI.Direction? = null,
+    val search: 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
+}
+
+@KtorExperimentalLocationsAPI
+private fun ArticleRepository.findVersions(request: ArticleVersionsRequest) =
+    findVersionsByVersionId(request.page, request.limit, request.article.versionId)
+
+@KtorExperimentalLocationsAPI
+fun Route.findArticleVersions(repo: ArticleRepository, voter: ArticleVoter) {
+    get<ArticleVersionsRequest> {
+        repo.findVersions(it)
+            .apply { voter.assert { canView(it.article, citizenOrNull) } }
+            .let { call.respond(it) }
+    }
+}

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

@@ -0,0 +1,46 @@
+package fr.dcproject.component.article.routes
+
+import fr.dcproject.citizenOrNull
+import fr.dcproject.component.article.ArticleForListing
+import fr.dcproject.component.article.ArticleRepository
+import fr.dcproject.component.article.ArticleVoter
+import fr.dcproject.voter.assert
+import fr.postgresjson.connexion.Paginated
+import fr.postgresjson.repository.RepositoryI
+import io.ktor.application.*
+import io.ktor.locations.*
+import io.ktor.response.*
+import io.ktor.routing.*
+
+@Location("/articles")
+class ArticlesRequest(
+    page: Int = 1,
+    limit: Int = 50,
+    val sort: String? = null,
+    val direction: RepositoryI.Direction? = null,
+    val search: String? = null,
+    val createdBy: String? = null,
+    val workgroup: 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
+}
+
+private fun ArticleRepository.findArticles(request: ArticlesRequest): Paginated<ArticleForListing> {
+    return find(
+        request.page,
+        request.limit,
+        request.sort,
+        request.direction,
+        request.search,
+        ArticleRepository.Filter(createdById = request.createdBy, workgroupId = request.workgroup)
+    )
+}
+
+fun Route.findArticles (repo: ArticleRepository, voter: ArticleVoter) {
+    get<ArticlesRequest> {
+        repo.findArticles(it)
+            .apply { voter.assert { canView(result, citizenOrNull) } }
+            .let { call.respond(it) }
+    }
+}

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

@@ -0,0 +1,69 @@
+package fr.dcproject.component.article.routes
+
+import fr.dcproject.citizenOrNull
+import fr.dcproject.component.article.ArticleForView
+import fr.dcproject.component.article.ArticleRepository
+import fr.dcproject.component.article.ArticleViewManager
+import fr.dcproject.component.article.ArticleVoter
+import fr.dcproject.component.article.routes.ArticleRequest.Output
+import fr.dcproject.dto.*
+import fr.dcproject.voter.assert
+import io.ktor.application.*
+import io.ktor.features.*
+import io.ktor.locations.*
+import io.ktor.response.*
+import io.ktor.routing.*
+import io.ktor.util.*
+import kotlinx.coroutines.launch
+import org.koin.core.KoinComponent
+import org.koin.core.inject
+import java.util.*
+
+
+@KtorExperimentalLocationsAPI
+@Location("/articles/{articleId}")
+class ArticleRequest(val articleId: UUID) : KoinComponent {
+    val repo: ArticleRepository by inject()
+
+    @KtorExperimentalAPI
+    val article: ArticleForView = repo.findById(articleId) ?: throw NotFoundException("Article $articleId not found")
+
+    class Output(
+        article: ArticleForView,
+        views: fr.dcproject.entity.ViewAggregation = fr.dcproject.entity.ViewAggregation()
+    ) : CreatedAt by CreatedAt.Imp(article),
+        Opinionable by Opinionable.Imp(article),
+        Votable by Votable.Imp(article),
+        Versionable by Versionable.Imp(article),
+        Viewable by Viewable.Imp(views) {
+        val id = article.id
+        val title = article.title
+        val anonymous = article.anonymous
+        val content = article.content
+        val description = article.description
+        val tags = article.tags
+        val draft = article.draft
+        val lastVersion = article.lastVersion
+        val createdBy = article.createdBy
+        val workgroup = article.workgroup // TODO change to workgroup DTO
+    }
+}
+
+@KtorExperimentalAPI
+@KtorExperimentalLocationsAPI
+fun Route.getOneArticle(viewManager: ArticleViewManager, voter: ArticleVoter) {
+    get<ArticleRequest> {
+        voter.assert { canView(it.article, citizenOrNull) }
+
+        Output(
+            it.article,
+            viewManager.getViewsCount(it.article)
+        ).also { out ->
+            call.respond(out)
+        }
+
+        launch {
+            viewManager.addView(call.request.local.remoteHost, it.article, citizenOrNull)
+        }
+    }
+}

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

@@ -0,0 +1,66 @@
+package fr.dcproject.component.article.route
+
+import fr.dcproject.citizen
+import fr.dcproject.citizenOrNull
+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.event.ArticleUpdate
+import fr.dcproject.event.raiseEvent
+import fr.dcproject.repository.Workgroup
+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
+@Location("/articles")
+class PostArticleRequest {
+    class Input(
+        val id: UUID?,
+        val title: String,
+        val anonymous: Boolean = true,
+        val content: String,
+        val description: String,
+        val tags: List<String> = emptyList(),
+        val draft: Boolean = false,
+        val versionId: UUID?,
+        val workgroup: WorkgroupRef? = null
+    )
+}
+
+@KtorExperimentalLocationsAPI
+fun Route.upsertArticle(repo: ArticleRepository, workgroupRepository: Workgroup, voter: ArticleVoter) {
+    suspend fun PipelineContext<Unit, ApplicationCall>.convertDtoToEntity(): ArticleForUpdate = call.receive<PostArticleRequest.Input>().run {
+        ArticleForUpdate(
+            id = id ?: UUID.randomUUID(),
+            title = title,
+            anonymous = anonymous,
+            content = content,
+            description = description,
+            tags = tags,
+            draft = draft,
+            createdBy = call.citizen,
+            workgroup = if (workgroup != null) workgroupRepository.findById(workgroup.id) else null,
+            versionId = versionId
+        )
+    }
+
+    post<PostArticleRequest> {
+        val article = convertDtoToEntity()
+
+        voter.assert { canUpsert(article, citizenOrNull) }
+
+        val newArticle: ArticleForView = repo.upsert(article) ?: error("Article not updated")
+
+        call.respond(newArticle)
+
+        raiseEvent(ArticleUpdate.event, ArticleUpdate(newArticle))
+    }
+}