Merge pull request #1 from JavaBy/feature/kotlin-mentions

Kotlin mentions processor

Author: madhead

.deploy/lambda/layers/libGL.zip

@@ -20,10 +20,27 @@ export class JProfByBotStack extends cdk.Stack {
       partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
       billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
     });
+    const kotlinMentionsTable = new dynamodb.Table(this, 'jprof-by-bot-table-kotlin-mentions', {
+      tableName: 'jprof-by-bot-table-kotlin-mentions',
+      partitionKey: { name: 'chat', type: dynamodb.AttributeType.NUMBER },
+      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
+    });
+    const layerLibGL = new lambda.LayerVersion(this, 'jprof-by-bot-lambda-layer-libGL', {
+      code: lambda.Code.fromAsset('layers/libGL.zip'),
+      compatibleRuntimes: [lambda.Runtime.JAVA_11],
+    });
+    const layerLibfontconfig = new lambda.LayerVersion(this, 'jprof-by-bot-lambda-layer-libfontconfig', {
+      code: lambda.Code.fromAsset('layers/libfontconfig.zip'),
+      compatibleRuntimes: [lambda.Runtime.JAVA_11],
+    });
 
     const lambdaWebhook = new lambda.Function(this, 'jprof-by-bot-lambda-webhook', {
       functionName: 'jprof-by-bot-lambda-webhook',
       runtime: lambda.Runtime.JAVA_11,
+      layers: [
+        layerLibGL,
+        layerLibfontconfig,
+      ],
       timeout: Duration.seconds(30),
       memorySize: 1024,
       code: lambda.Code.fromAsset('../../runners/lambda/build/libs/jprof_by_bot-runners-lambda-all.jar'),
@@ -32,13 +49,15 @@ export class JProfByBotStack extends cdk.Stack {
         'LOG_THRESHOLD': 'DEBUG',
         'TABLE_VOTES': votesTable.tableName,
         'TABLE_YOUTUBE_CHANNELS_WHITELIST': youtubeChannelsWhitelistTable.tableName,
+        'TABLE_KOTLIN_MENTIONS': kotlinMentionsTable.tableName,
         'TOKEN_TELEGRAM_BOT': props.telegramToken,
         'TOKEN_YOUTUBE_API': props.youtubeToken,
       },
     });
 
     votesTable.grantReadWriteData(lambdaWebhook);
     youtubeChannelsWhitelistTable.grantReadData(lambdaWebhook);
+    kotlinMentionsTable.grantReadWriteData(lambdaWebhook);
 
     const api = new apigateway.RestApi(this, 'jprof-by-bot-api', {
       restApiName: 'jprof-by-bot-api',

.deploy/lambda/layers/libfontconfig.zip

@@ -56,6 +56,7 @@ jobs:
           read-only: ${{ github.ref != 'refs/heads/master' }}
       - run: votes/dynamodb/src/test/resources/seed.sh
       - run: youtube/dynamodb/src/test/resources/seed.sh
+      - run: kotlin/dynamodb/src/test/resources/seed.sh
       - run: ./gradlew clean dbTest
       - uses: actions/upload-artifact@v2
         if: always()

.deploy/lambda/lib/JProfByBotStack.ts

@@ -10,6 +10,7 @@ plugins {
 subprojects {
     repositories {
         mavenCentral()
+        maven("https://packages.jetbrains.team/maven/p/skija/maven")
     }
 
     tasks {

.github/workflows/default.yml

@@ -14,6 +14,8 @@ tgbotapi = "0.33.3"
 
 jsoup = "1.13.1"
 
+skija = "0.91.4"
+
 google-api-services-youtube = "v3-rev20210410-1.31.0"
 
 log4j = "2.14.1"
@@ -40,6 +42,11 @@ tgbotapi-extensions-utils = { group = "dev.inmo", name = "tgbotapi.extensions.ut
 
 jsoup = { group = "org.jsoup", name = "jsoup", version.ref = "jsoup" }
 
+skija-linux = { group = "org.jetbrains.skija", name = "skija-linux", version.ref = "skija" }
+skija-macos-arm64 = { group = "org.jetbrains.skija", name = "skija-macos-arm64", version.ref = "skija" }
+skija-macos-x64 = { group = "org.jetbrains.skija", name = "skija-macos-x64", version.ref = "skija" }
+skija-windows = { group = "org.jetbrains.skija", name = "skija-windows", version.ref = "skija" }
+
 google-api-services-youtube = { group = "com.google.apis", name = "google-api-services-youtube", version.ref = "google-api-services-youtube" }
 
 log4j-api = { group = "org.apache.logging.log4j", name = "log4j-api", version.ref = "log4j" }

build.gradle.kts

@@ -0,0 +1,19 @@
+plugins {
+    kotlin("jvm")
+}
+
+dependencies {
+    api(project.projects.core)
+    api(libs.tgbotapi.core)
+    implementation(libs.log4j.api)
+    implementation(libs.tgbotapi.extensions.api)
+    implementation(libs.tgbotapi.extensions.utils)
+//    implementation(libs.skija.windows)
+    implementation(libs.skija.linux)
+
+    testImplementation(libs.junit.jupiter.api)
+    testImplementation(libs.junit.jupiter.params)
+    testImplementation(libs.mockk)
+    testRuntimeOnly(libs.junit.jupiter.engine)
+    testRuntimeOnly(libs.log4j.core)
+}

gradle/libs.versions.toml

@@ -0,0 +1,28 @@
+plugins {
+    kotlin("jvm")
+}
+
+dependencies {
+    api(project.projects.kotlin)
+    api(libs.dynamodb)
+    implementation(project.projects.utils.dynamodb)
+    implementation(libs.kotlinx.coroutines.jdk8)
+
+    testImplementation(libs.junit.jupiter.api)
+    testImplementation(libs.junit.jupiter.params)
+    testImplementation(libs.aws.junit5.dynamo.v2)
+    testImplementation(project.projects.utils.awsJunit5)
+    testRuntimeOnly(libs.junit.jupiter.engine)
+}
+
+tasks {
+    val dbTest by registering(Test::class) {
+        group = LifecycleBasePlugin.VERIFICATION_GROUP
+        description = "Runs the DB tests."
+        shouldRunAfter("test")
+        outputs.upToDateWhen { false }
+        useJUnitPlatform {
+            includeTags("db")
+        }
+    }
+}

kotlin/build.gradle.kts

@@ -0,0 +1,65 @@
+package by.jprof.telegram.bot.kotlin.dynamodb.dao
+
+import by.jprof.telegram.bot.kotlin.dao.KotlinMentionsDAO
+import by.jprof.telegram.bot.kotlin.model.KotlinMentions
+import by.jprof.telegram.bot.kotlin.model.UserStatistics
+import by.jprof.telegram.bot.utils.dynamodb.toAttributeValue
+import by.jprof.telegram.bot.utils.dynamodb.toInstant
+import by.jprof.telegram.bot.utils.dynamodb.toLong
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.future.await
+import kotlinx.coroutines.withContext
+import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient
+import software.amazon.awssdk.services.dynamodb.model.AttributeValue
+
+class KotlinMentionsDAO(
+    private val dynamoDb: DynamoDbAsyncClient,
+    private val table: String
+) : KotlinMentionsDAO {
+    override suspend fun save(kotlinMentions: KotlinMentions) {
+        withContext(Dispatchers.IO) {
+            dynamoDb.putItem {
+                it.tableName(table)
+                it.item(kotlinMentions.toAttributes())
+            }.await()
+        }
+    }
+
+    override suspend fun get(chat: Long): KotlinMentions? {
+        return withContext(Dispatchers.IO) {
+            dynamoDb.getItem {
+                it.tableName(table)
+                it.key(mapOf("chat" to chat.toAttributeValue()))
+            }.await()?.item()?.takeUnless { it.isEmpty() }?.toKotlinMentions()
+        }
+    }
+}
+
+fun UserStatistics.toAttributes(): Map<String, AttributeValue> = mapOf(
+    "count" to this.count.toAttributeValue(),
+    "lastMention" to this.lastMention.toAttributeValue(),
+)
+
+fun KotlinMentions.toAttributes(): Map<String, AttributeValue> = mapOf(
+    "chat" to this.chat.toAttributeValue(),
+    "lastMention" to this.lastMention.toAttributeValue(),
+    "usersStatistics" to this.usersStatistics
+        .mapKeys { it.key.toString() }
+        .mapValues { AttributeValue.builder().m(it.value.toAttributes()).build() }
+        .toAttributeValue()
+)
+
+fun Map<String, AttributeValue>.toUserStatistics(): UserStatistics = UserStatistics(
+    count = this["count"].toLong("count"),
+    lastMention = this["lastMention"].toInstant("lastMention"),
+)
+
+fun Map<String, AttributeValue>.toKotlinMentions(): KotlinMentions = KotlinMentions(
+    chat = this["chat"].toLong("chat"),
+    lastMention = this["lastMention"].toInstant("lastMention"),
+    usersStatistics = this["usersStatistics"]?.m()?.let {
+        it
+            .mapValues { (_, value) -> value.m().toUserStatistics() }
+            .mapKeys { (key, _) -> key.toLong() }
+    } ?: emptyMap()
+)

kotlin/dynamodb/build.gradle.kts

@@ -0,0 +1,51 @@
+package by.jprof.telegram.bot.kotlin.dynamodb.dao
+
+import by.jprof.telegram.bot.kotlin.model.KotlinMentions
+import by.jprof.telegram.bot.kotlin.model.UserStatistics
+import by.jprof.telegram.bot.utils.aws_junit5.Endpoint
+import kotlinx.coroutines.runBlocking
+import me.madhead.aws_junit5.common.AWSClient
+import me.madhead.aws_junit5.dynamo.v2.DynamoDB
+import org.junit.jupiter.api.*
+import org.junit.jupiter.api.extension.ExtendWith
+import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient
+import java.time.Instant
+
+@Tag("db")
+@ExtendWith(DynamoDB::class)
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+internal class KotlinMentionsDAOTest {
+    @AWSClient(endpoint = Endpoint::class)
+    private lateinit var dynamoDB: DynamoDbAsyncClient
+    private lateinit var sut: KotlinMentionsDAO
+
+    @BeforeAll
+    internal fun setup() {
+        sut = KotlinMentionsDAO(dynamoDB, "kotlin-mentions")
+    }
+
+    @Test
+    fun save() = runBlocking {
+        sut.save(kotlinMentions)
+    }
+
+    @Test
+    fun get() = runBlocking {
+        Assertions.assertEquals(kotlinMentions, sut.get(42))
+    }
+
+    @Test
+    fun getUnexisting() = runBlocking {
+        Assertions.assertNull(sut.get(-42))
+    }
+
+    private val kotlinMentions
+        get() = KotlinMentions(
+            chat = 42L,
+            lastMention = Instant.ofEpochMilli(1227376823000),
+            usersStatistics = mapOf(
+                1L to UserStatistics(2, Instant.ofEpochMilli(1227376823000)),
+                2L to UserStatistics(1, Instant.ofEpochMilli(1214996810000)),
+            )
+        )
+}