Support custom integration routes, add WebUntis exam calendars

Author: SIMULATAN

api/build.gradle.kts

@@ -14,4 +14,7 @@ dependencies {
     implementation(database.exposed.core)
     api(libraries.jobrunr)
     api(log.kotlinLogging)
+    implementation(ktor.server.core)
+    implementation(ktor.server.auth)
+    implementation(ktor.server.auth.jwt)
 }

src/main/kotlin/me/snoty/backend/server/handler/HttpStatusException.kt api/src/main/kotlin/me/snoty/backend/utils/HttpStatusException.kt

@@ -1,4 +1,4 @@
-package me.snoty.backend.server.handler
+package me.snoty.backend.utils
 
 import io.ktor.http.*
 import kotlinx.serialization.KSerializer

api/src/main/kotlin/me/snoty/backend/utils/SecurityUtils.kt

@@ -0,0 +1,20 @@
+package me.snoty.backend.utils
+
+import io.ktor.server.application.*
+import io.ktor.server.auth.*
+import io.ktor.server.auth.jwt.*
+import me.snoty.backend.User
+import java.util.*
+
+fun ApplicationCall.getUser(): User =
+	getUserOrNull() ?: throw UnauthorizedException("User not authenticated")
+
+fun ApplicationCall.getUserOrNull(): User? {
+	val principal = authentication.principal<JWTPrincipal>() ?: return null
+	val claims = principal.payload.claims
+	return User(
+		id = claims["sub"]?.`as`(UUID::class.java) ?: NULL_UUID,
+		name = claims["preferred_username"]?.asString() ?: "unknown",
+		email = claims["email"]?.asString() ?: "unknown"
+	)
+}

api/src/main/kotlin/me/snoty/backend/utils/SqlUtils.kt

@@ -11,11 +11,11 @@ import org.jetbrains.exposed.sql.Function
  * 3. The value to return if the condition is false
  * 4. The Type of the results
  */
-class When<T>(
+class When<T : Any>(
 	private val condition: Expression<*>,
 	private val ifTrue: Expression<T>,
 	private val ifFalse: Expression<T>?,
-	columnType: IColumnType
+	columnType: IColumnType<T>
 ) : Function<T>(columnType) {
 	override fun toQueryBuilder(queryBuilder: QueryBuilder) {
 		queryBuilder {

src/main/kotlin/me/snoty/backend/utils/Utils.kt api/src/main/kotlin/me/snoty/backend/utils/Utils.kt

@@ -19,6 +19,10 @@ dependencies {
     api(ktor.client.contentNegotiation)
     api(ktor.serialization.kotlinx.json)
     api(projects.api)
+    api(ktor.server.core)
+    api(ktor.server.auth)
+    api(libraries.jackson.core)
+    api(libraries.jackson.kotlin)
     testImplementation(kotlin("test"))
 }
 

integrations/api/build.gradle.kts

@@ -2,10 +2,10 @@ package me.snoty.integration.common
 
 import io.micrometer.core.instrument.MeterRegistry
 import me.snoty.backend.User
-import me.snoty.integration.common.diff.EntityDiffMetrics
-import me.snoty.integration.common.diff.EntityStateTable
 import me.snoty.backend.scheduling.JobRequest
 import me.snoty.backend.scheduling.Scheduler
+import me.snoty.integration.common.diff.EntityDiffMetrics
+import me.snoty.integration.common.diff.EntityStateTable
 import org.jetbrains.exposed.sql.Database
 import org.jetbrains.exposed.sql.SchemaUtils
 import org.jetbrains.exposed.sql.transactions.transaction
@@ -52,21 +52,23 @@ abstract class AbstractIntegration<S : IntegrationSettings, R : JobRequest>(
 		scheduleAll()
 	}
 
+	override fun setup(user: User, settings: IntegrationSettings)
+		= IntegrationConfigTable.create(user.id, name, settings)
+
 	private fun scheduleAll() {
 		val allSettings = IntegrationConfigTable.getAllIntegrationConfigs<S>(name)
 		allSettings.forEach(::schedule)
 	}
 
 	abstract fun createRequest(config: IntegrationConfig<S>): JobRequest
-	abstract fun getInstanceId(config: IntegrationConfig<S>): Int
 
-	override fun schedule(user: User, settings: Any) {
+	override fun schedule(user: User, settings: IntegrationSettings) {
 		@Suppress("UNCHECKED_CAST")
 		val integrationConfig = IntegrationConfig(user.id, settings as S)
 		schedule(integrationConfig)
 	}
 
 	private fun schedule(config: IntegrationConfig<S>) {
-		scheduler.scheduleJob(listOf(getInstanceId(config), config.user), createRequest(config))
+		scheduler.scheduleJob(listOf(config.settings.instanceId, config.user), createRequest(config))
 	}
 }

integrations/api/src/main/kotlin/me/snoty/integration/common/AbstractIntegration.kt

@@ -1,16 +1,22 @@
 package me.snoty.integration.common
 
+import io.ktor.server.routing.*
 import me.snoty.backend.User
 import kotlin.reflect.KClass
 
 
 interface Integration {
 	val name: String
-	val settingsType: KClass<out Any>
+	val settingsType: KClass<out IntegrationSettings>
 	val fetcher: IntegrationFetcher<*>
 
 	fun start()
-	fun schedule(user: User, settings: Any)
+	fun schedule(user: User, settings: IntegrationSettings)
+	fun setup(user: User, settings: IntegrationSettings): Long
+
+	fun routes(routing: Route) {
+		// default implementation does nothing
+	}
 }
 
 interface IntegrationFactory {

integrations/api/src/main/kotlin/me/snoty/integration/common/Integration.kt

@@ -1,20 +1,27 @@
 package me.snoty.integration.common
 
-import kotlinx.serialization.json.Json
-import org.jetbrains.exposed.dao.id.IdTable
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.fasterxml.jackson.module.kotlin.readValue
+import org.jetbrains.exposed.dao.id.LongIdTable
 import org.jetbrains.exposed.sql.SchemaUtils
+import org.jetbrains.exposed.sql.and
+import org.jetbrains.exposed.sql.insertAndGetId
 import org.jetbrains.exposed.sql.json.jsonb
 import org.jetbrains.exposed.sql.transactions.transaction
 import java.util.*
 
 data class IntegrationConfig<S>(val user: UUID, val settings: S)
 
-object IntegrationConfigTable : IdTable<Long>() {
-	override val id = long("id").entityId()
+val mapper = jacksonObjectMapper()
 
+object IntegrationConfigTable : LongIdTable() {
 	val user = uuid("user")
 	private val integrationType = varchar("integration_type", 255)
-	private val settings = jsonb<IntegrationSettings>("config", Json)
+	private val settings = jsonb<IntegrationSettings>(
+		"config",
+		{ mapper.writeValueAsString(it) },
+		{ mapper.readValue(it) }
+	)
 
 	init {
 		transaction {
@@ -30,4 +37,20 @@ object IntegrationConfigTable : IdTable<Long>() {
 				IntegrationConfig(row[user], row[settings] as S)
 			}
 	}
+
+	fun <S> get(id: Long, integrationType: String) = transaction {
+		@Suppress("UNCHECKED_CAST")
+		select(settings)
+			.where { IntegrationConfigTable.id eq id and (IntegrationConfigTable.integrationType eq integrationType) }
+			.firstOrNull()
+			?.get(settings) as S?
+	}
+
+	fun <S : IntegrationSettings> create(userId: UUID, integrationType: String, settings: S) = transaction {
+		insertAndGetId {
+			it[user] = userId
+			it[this.integrationType] = integrationType
+			it[this.settings] = settings
+		}.value
+	}
 }

integrations/api/src/main/kotlin/me/snoty/integration/common/IntegrationConfigTable.kt

@@ -1,6 +1,8 @@
 package me.snoty.integration.common
 
-import kotlinx.serialization.Serializable
+import com.fasterxml.jackson.annotation.JsonTypeInfo
 
-@Serializable
-open class IntegrationSettings
+@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.PROPERTY, property = "@class")
+interface IntegrationSettings {
+	val instanceId: Int
+}

integrations/api/src/main/kotlin/me/snoty/integration/common/IntegrationSettings.kt

@@ -8,13 +8,14 @@ import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import org.jetbrains.exposed.sql.SqlExpressionBuilder.neq
 import org.jetbrains.exposed.sql.json.jsonb
 import org.jetbrains.exposed.sql.transactions.transaction
+import java.util.UUID
 
 const val ID = "id"
 abstract class EntityStateTable<ID>(
 	json: Json = Json
 ) : Table() {
 	abstract val id: Column<ID>
-	private val instanceId = integer("instance_id")
+	val instanceId = integer("instance_id")
 
 	/**
 	 * Override this with `buildPrimaryKey()` to define the primary key
@@ -23,9 +24,10 @@ abstract class EntityStateTable<ID>(
 	abstract override val primaryKey: PrimaryKey
 	fun buildPrimaryKey() = PrimaryKey(id, instanceId)
 
-	private val type = varchar("type", 255)
-	private val state = jsonb<Fields>("state", json)
+	val type = varchar("type", 255)
+	val state = jsonb<Fields>("state", json)
 	private val checksum = long("checksum")
+	val userId = uuid("user_id").nullable()
 
 	private fun deleteIdentifier(instanceId: InstanceId, entity: IUpdatableEntity<ID>): EntityStateTable<ID>.(ISqlExpressionBuilder) -> Op<Boolean> = {
 		(id eq entity.id) and (type eq entity.type) and (this.instanceId eq instanceId)
@@ -53,7 +55,7 @@ abstract class EntityStateTable<ID>(
 		return entity.diff(result[stateQuery])
 	}
 
-	fun compareAndUpdateState(instanceId: InstanceId, entity: IUpdatableEntity<ID>): DiffResult = transaction {
+	fun compareAndUpdateState(entity: IUpdatableEntity<ID>, instanceId: InstanceId, userId: UUID): DiffResult = transaction {
 		val diffResult = compareState(instanceId, entity)
 		when (diffResult) {
 			// entity has changed since last time
@@ -67,6 +69,7 @@ abstract class EntityStateTable<ID>(
 			is DiffResult.Created -> {
 				insert {
 					it[id] = entity.id
+					it[this.userId] = userId
 					it[this.instanceId] = instanceId
 					it[type] = entity.type
 					it[state] = entity.fields

integrations/api/src/main/kotlin/me/snoty/integration/common/diff/EntityStateTable.kt

@@ -1,13 +1,18 @@
 package me.snoty.integration.common.diff
 
-import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.*
 
 data class OldNew<T>(val old: T, val new: T)
 typealias Diff = Map<String, OldNew<Any>>
 
 typealias Fields = JsonObject
 fun Fields.checksum() = hashCode().toLong()
 
+fun Fields.getString(key: String): String = get(key)!!.jsonPrimitive.content
+fun Fields.getInt(key: String): Int = get(key)!!.jsonPrimitive.int
+fun Fields.getLong(key: String): Long = get(key)!!.jsonPrimitive.long
+fun Fields.getJsonArray(key: String): JsonArray = get(key)!!.jsonArray
+
 sealed class DiffResult {
 	data object Unchanged : DiffResult()
 	data class Created(val checksum: Long, val fields: Fields) : DiffResult()

integrations/api/src/main/kotlin/me/snoty/integration/common/diff/Updatable.kt

@@ -8,24 +8,25 @@ import me.snoty.integration.common.IntegrationFetcherFactory
 import me.snoty.integration.common.diff.EntityDiffMetrics
 import me.snoty.integration.common.diff.IUpdatableEntity
 import me.snoty.integration.moodle.request.getCalendarUpcoming
+import java.util.UUID
 
 open class MoodleFetcher(
 	private val entityDiffMetrics: EntityDiffMetrics,
 	private val moodleAPI: MoodleAPI = MoodleAPIImpl()
 ) : IntegrationFetcher<MoodleJobRequest> {
 	private val logger = KotlinLogging.logger {}
 
-	private fun updateStates(instanceId: InstanceId, elements: List<IUpdatableEntity<Long>>) {
+	private fun updateStates(elements: List<IUpdatableEntity<Long>>, instanceId: InstanceId, userId: UUID) {
 		elements.forEach {
-			val result = MoodleEntityStateTable.compareAndUpdateState(instanceId, it)
+			val result = MoodleEntityStateTable.compareAndUpdateState(it, instanceId, userId)
 			entityDiffMetrics.process(result)
 		}
 	}
 
-	private suspend fun fetchAssignments(moodleSettings: MoodleSettings) {
+	private suspend fun fetchAssignments(moodleSettings: MoodleSettings, userId: UUID) {
 		val instanceId = moodleSettings.baseUrl.hashCode()
 		val assignments = moodleAPI.getCalendarUpcoming(moodleSettings)
-		updateStates(instanceId, assignments)
+		updateStates(assignments, instanceId, userId)
 		logger.info { "Fetched ${assignments.size} assignments for ${moodleSettings.username}" }
 		// TODO: send update events
 	}
@@ -35,6 +36,6 @@ open class MoodleFetcher(
 	}
 
 	override fun run(jobRequest: MoodleJobRequest) = runBlocking {
-		fetchAssignments(jobRequest.settings)
+		fetchAssignments(jobRequest.settings, jobRequest.userId)
 	}
 }

integrations/moodle/src/main/kotlin/me/snoty/integration/moodle/MoodleFetcher.kt

@@ -13,7 +13,9 @@ data class MoodleSettings(
 	val baseUrl: String,
 	val username: String,
 	val appSecret: String
-) : IntegrationSettings()
+) : IntegrationSettings {
+	override val instanceId: Int = baseUrl.hashCode()
+}
 
 object MoodleEntityStateTable : EntityStateTable<Long>() {
 	override val id: Column<Long> = long(ID)
@@ -34,9 +36,6 @@ class MoodleIntegration(
 		const val INTEGRATION_NAME = "moodle"
 	}
 
-	override fun getInstanceId(config: IntegrationConfig<MoodleSettings>) =
-		config.settings.baseUrl.hashCode()
-
 	override fun createRequest(config: IntegrationConfig<MoodleSettings>): JobRequest =
 		MoodleJobRequest(config.user, config.settings)
 

integrations/moodle/src/main/kotlin/me/snoty/integration/moodle/MoodleIntegration.kt

@@ -9,6 +9,7 @@ repositories {
 
 dependencies {
     compileOnly(projects.integrations.api)
+    implementation("org.mnode.ical4j:ical4j:4.0.0-rc6")
 
     testImplementation(tests.junit.api)
     testImplementation(libraries.kotlinx.serialization)

integrations/webuntis/build.gradle.kts

@@ -8,24 +8,25 @@ import me.snoty.integration.common.IntegrationFetcherFactory
 import me.snoty.integration.common.diff.EntityDiffMetrics
 import me.snoty.integration.common.diff.IUpdatableEntity
 import me.snoty.integration.untis.request.getExams
+import java.util.UUID
 
 class WebUntisFetcher(
 	private val entityDiffMetrics: EntityDiffMetrics,
 	private val untis: WebUntisAPI = WebUntisAPIImpl()
 ) : IntegrationFetcher<WebUntisJobRequest> {
 	private val logger = KotlinLogging.logger {}
 
-	private fun updateStates(instanceId: InstanceId, elements: List<IUpdatableEntity<Int>>) {
+	private fun updateStates(instanceId: InstanceId, elements: List<IUpdatableEntity<Int>>, userId: UUID) {
 		elements.forEach {
-			val result = WebUntisEntityStateTable.compareAndUpdateState(instanceId, it)
+			val result = WebUntisEntityStateTable.compareAndUpdateState(it, instanceId, userId)
 			entityDiffMetrics.process(result)
 		}
 	}
 
-	private suspend fun fetchExams(untisSettings: WebUntisSettings) {
+	private suspend fun fetchExams(untisSettings: WebUntisSettings, userId: UUID) {
 		val instanceId = untisSettings.baseUrl.hashCode()
 		val exams = untis.getExams(untisSettings)
-		updateStates(instanceId, exams)
+		updateStates(instanceId, exams, userId)
 		logger.info { "Fetched ${exams.size} exams for ${untisSettings.username}" }
 	}
 
@@ -34,6 +35,6 @@ class WebUntisFetcher(
 	}
 
 	override fun run(jobRequest: WebUntisJobRequest) = runBlocking {
-		fetchExams(jobRequest.settings)
+		fetchExams(jobRequest.settings, jobRequest.userId)
 	}
 }