feat(dao): Apply a hierarchy filter when listing repositories

Extend the `RepositoryRepository.list()` function to support a
`HierarchyFiler`. This allows to query a specific set of repositories;
for instance, all those a user can access.

To make this possible, add some more helper extension functions for the
`dao` module.

Signed-off-by: Oliver Heger <[email protected]>

Author: oheger-bosch

dao/src/main/kotlin/repositories/repository/DaoRepositoryRepository.kt

@@ -21,17 +21,25 @@ package org.eclipse.apoapsis.ortserver.dao.repositories.repository
 
 import org.eclipse.apoapsis.ortserver.dao.blockingQuery
 import org.eclipse.apoapsis.ortserver.dao.entityQuery
+import org.eclipse.apoapsis.ortserver.dao.repositories.product.ProductsTable
+import org.eclipse.apoapsis.ortserver.dao.utils.andCond
+import org.eclipse.apoapsis.ortserver.dao.utils.apply
 import org.eclipse.apoapsis.ortserver.dao.utils.applyRegex
+import org.eclipse.apoapsis.ortserver.dao.utils.excludesCondition
+import org.eclipse.apoapsis.ortserver.dao.utils.extractIds
 import org.eclipse.apoapsis.ortserver.dao.utils.listQuery
+import org.eclipse.apoapsis.ortserver.model.CompoundHierarchyId
 import org.eclipse.apoapsis.ortserver.model.Hierarchy
 import org.eclipse.apoapsis.ortserver.model.RepositoryType
 import org.eclipse.apoapsis.ortserver.model.repositories.RepositoryRepository
 import org.eclipse.apoapsis.ortserver.model.util.FilterParameter
+import org.eclipse.apoapsis.ortserver.model.util.HierarchyFilter
 import org.eclipse.apoapsis.ortserver.model.util.ListQueryParameters
 import org.eclipse.apoapsis.ortserver.model.util.OptionalValue
 
 import org.jetbrains.exposed.sql.Database
 import org.jetbrains.exposed.sql.Op
+import org.jetbrains.exposed.sql.SqlExpressionBuilder
 import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import org.jetbrains.exposed.sql.and
 import org.jetbrains.exposed.sql.deleteWhere
@@ -56,17 +64,22 @@ class DaoRepositoryRepository(private val db: Database) : RepositoryRepository {
         Hierarchy(repository.mapToModel(), product.mapToModel(), organization.mapToModel())
     }
 
-    override fun list(parameters: ListQueryParameters, filter: FilterParameter?) =
+    override fun list(parameters: ListQueryParameters, urlFilter: FilterParameter?, hierarchyFilter: HierarchyFilter) =
         db.blockingQuery {
-            RepositoryDao.listQuery(parameters, RepositoryDao::mapToModel) {
-                var condition: Op<Boolean> = Op.TRUE
-                filter?.let {
-                    condition = condition and RepositoriesTable.url.applyRegex(
-                        it.value
-                    )
-                }
-                condition
+            val urlCondition = urlFilter?.let {
+                RepositoriesTable.url.applyRegex(it.value)
+            } ?: Op.TRUE
+
+            val builder = hierarchyFilter.apply(
+                urlCondition andCond hierarchyFilter.excludesCondition(
+                    RepositoriesTable.id,
+                    CompoundHierarchyId.REPOSITORY_LEVEL
+                )
+            ) { level, ids, filter ->
+                generateHierarchyCondition(level, ids, filter)
             }
+
+            RepositoryDao.listQuery(parameters, RepositoryDao::mapToModel, builder)
         }
 
     override fun listForProduct(productId: Long, parameters: ListQueryParameters, filter: FilterParameter?) =
@@ -101,3 +114,29 @@ class DaoRepositoryRepository(private val db: Database) : RepositoryRepository {
         RepositoriesTable.deleteWhere { RepositoriesTable.productId eq productId }
     }
 }
+
+/**
+ * Generate a condition defined by a [HierarchyFilter] for the given [level], [ids], and [filter].
+ */
+private fun SqlExpressionBuilder.generateHierarchyCondition(
+    level: Int,
+    ids: List<CompoundHierarchyId>,
+    filter: HierarchyFilter
+): Op<Boolean> =
+    when (level) {
+        CompoundHierarchyId.REPOSITORY_LEVEL ->
+            RepositoriesTable.id inList ids.extractIds(CompoundHierarchyId.REPOSITORY_LEVEL)
+
+        CompoundHierarchyId.PRODUCT_LEVEL ->
+            RepositoriesTable.productId inList ids.extractIds(CompoundHierarchyId.PRODUCT_LEVEL)
+
+        CompoundHierarchyId.ORGANIZATION_LEVEL -> {
+            val subquery = ProductsTable.select(ProductsTable.id).where {
+                (ProductsTable.organizationId inList ids.extractIds(CompoundHierarchyId.ORGANIZATION_LEVEL)) andCond
+                        filter.excludesCondition(ProductsTable.id, CompoundHierarchyId.PRODUCT_LEVEL)
+            }
+            RepositoriesTable.productId inSubQuery subquery
+        }
+
+        else -> Op.FALSE
+    }

dao/src/main/kotlin/utils/Extensions.kt

@@ -28,7 +28,9 @@ import kotlinx.datetime.minus
 
 import org.eclipse.apoapsis.ortserver.dao.ConditionBuilder
 import org.eclipse.apoapsis.ortserver.dao.QueryParametersException
+import org.eclipse.apoapsis.ortserver.model.CompoundHierarchyId
 import org.eclipse.apoapsis.ortserver.model.util.ComparisonOperator
+import org.eclipse.apoapsis.ortserver.model.util.HierarchyFilter
 import org.eclipse.apoapsis.ortserver.model.util.ListQueryParameters
 import org.eclipse.apoapsis.ortserver.model.util.ListQueryResult
 import org.eclipse.apoapsis.ortserver.model.util.OrderDirection
@@ -46,6 +48,7 @@ import org.jetbrains.exposed.sql.QueryParameter
 import org.jetbrains.exposed.sql.ResultRow
 import org.jetbrains.exposed.sql.SizedIterable
 import org.jetbrains.exposed.sql.SortOrder
+import org.jetbrains.exposed.sql.SqlExpressionBuilder
 import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import org.jetbrains.exposed.sql.SqlExpressionBuilder.greater
 import org.jetbrains.exposed.sql.SqlExpressionBuilder.greaterEq
@@ -55,6 +58,9 @@ import org.jetbrains.exposed.sql.SqlExpressionBuilder.lessEq
 import org.jetbrains.exposed.sql.SqlExpressionBuilder.neq
 import org.jetbrains.exposed.sql.SqlExpressionBuilder.notInList
 import org.jetbrains.exposed.sql.TextColumnType
+import org.jetbrains.exposed.sql.and
+import org.jetbrains.exposed.sql.not
+import org.jetbrains.exposed.sql.or
 
 /**
  * Transform the given column to an [EntityID] when creating a DAO object. This can be used for foreign key columns to
@@ -80,6 +86,61 @@ fun <T : Instant?> Column<T>.transformToDatabasePrecision() =
  */
 fun Instant.toDatabasePrecision() = minus(nanosecondsOfSecond, DateTimeUnit.NANOSECOND)
 
+/**
+ * Extract the defined IDs on the specified [level] from the [CompoundHierarchyId]s in this collection as long values.
+ */
+fun Collection<CompoundHierarchyId>.extractIds(level: Int): List<Long> = mapNotNull { it[level]?.value }
+
+/**
+ * Definition of a function type for generating query conditions based on accessible hierarchy elements. The function
+ * has access to a [SqlExpressionBuilder] to create the conditions. It is passed the level in the hierarchy to filter
+ * by, a list with the IDs to be included together with their child elements, and the filter itself to gain access to
+ * additional properties. The function returns an [Op] representing the condition. The conditions for the different
+ * hierarchy levels are then combined using an `OR` operator.
+ */
+typealias HierarchyConditionGenerator = SqlExpressionBuilder.(
+    Int,
+    List<CompoundHierarchyId>,
+    HierarchyFilter
+) -> Op<Boolean>
+
+/**
+ * Generate a condition for this [HierarchyFilter] using the provided [generator] function. The [generator] is
+ * responsible for creating the conditions on each hierarchy level. This function combines these conditions using an
+ * `OR` operator. The result is then combined with the optional [otherCondition] using an `AND` operator.
+ */
+fun HierarchyFilter.apply(
+    otherCondition: Op<Boolean> = Op.TRUE,
+    generator: HierarchyConditionGenerator
+): ConditionBuilder = {
+    if (isWildcard) {
+        otherCondition
+    } else {
+        val hierarchyCondition = transitiveIncludes.entries.fold(Op.FALSE as Op<Boolean>) { op, (level, ids) ->
+            val condition = generator(this, level, ids, this@apply)
+            op or condition
+        }
+
+        otherCondition and hierarchyCondition
+    }
+}
+
+/**
+ * Generate a conditional exclusion condition for the given [filter] for the specified [column] at the given hierarchy
+ * [level]. The function obtains the IDs to be excluded at the given [level] and constructs a `NOT IN` condition if
+ * this list is not empty.
+ */
+fun HierarchyFilter.excludesCondition(column: Column<EntityID<Long>>, level: Int): Op<Boolean>? =
+    excludes[level]?.takeUnless { it.isEmpty() }?.let { excludes ->
+        not(column inList excludes.extractIds(level))
+    }
+
+/**
+ * Construct a logic `AND` condition with an optional [op]. If [op] is null, return this condition.
+ */
+infix fun Op<Boolean>.andCond(op: Expression<Boolean>?): Op<Boolean> =
+    op?.let { this and it } ?: this
+
 /**
  * Run the provided [query] with the given [parameters] to create a [ListQueryResult]. The entities are mapped to the
  * corresponding model objects using the provided [entityMapper].