Merge pull request #30 from /issues/29

Fix #29: Convert monetary amounts

Author: madhead

currencies/README.adoc

@@ -0,0 +1,3 @@
+= Currencies
+
+This feature extracts monetary amounts from the messages and converts them to well-known currencies, like EUR or USD.

currencies/build.gradle.kts

@@ -0,0 +1,21 @@
+plugins {
+    kotlin("jvm")
+    kotlin("plugin.serialization")
+}
+
+dependencies {
+    implementation(platform(libs.ktor.bom))
+
+    api(project.projects.core)
+    api(libs.tgbotapi.core)
+    implementation(libs.tgbotapi.extensions.api)
+    implementation(libs.log4j.api)
+    implementation(libs.ktor.client.apache)
+    implementation(libs.ktor.client.serialization)
+
+    testImplementation(libs.junit.jupiter.api)
+    testImplementation(libs.junit.jupiter.params)
+    testImplementation(libs.mockk)
+    testRuntimeOnly(libs.junit.jupiter.engine)
+    testRuntimeOnly(libs.log4j.core)
+}

currencies/src/main/kotlin/by/jprof/telegram/bot/currencies/CurrenciesUpdateProcessor.kt

@@ -0,0 +1,57 @@
+package by.jprof.telegram.bot.currencies
+
+import by.jprof.telegram.bot.core.UpdateProcessor
+import by.jprof.telegram.bot.currencies.parser.MonetaryAmountParsingPipeline
+import by.jprof.telegram.bot.currencies.rates.ExchangeRateClient
+import dev.inmo.tgbotapi.bot.RequestsExecutor
+import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.types.ParseMode.MarkdownV2ParseMode
+import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
+import dev.inmo.tgbotapi.types.message.content.TextContent
+import dev.inmo.tgbotapi.types.update.CallbackQueryUpdate
+import dev.inmo.tgbotapi.types.update.MessageUpdate
+import dev.inmo.tgbotapi.types.update.abstracts.Update
+import dev.inmo.tgbotapi.utils.extensions.escapeMarkdownV2Common
+import org.apache.logging.log4j.LogManager
+
+class CurrenciesUpdateProcessor(
+    private val monetaryAmountParsingPipeline: MonetaryAmountParsingPipeline,
+    private val exchangeRateClient: ExchangeRateClient,
+    private val targetCurrencies: List<String> = listOf("EUR", "USD"),
+    private val bot: RequestsExecutor,
+) : UpdateProcessor {
+    companion object {
+        private val logger = LogManager.getLogger(CurrenciesUpdateProcessor::class.java)!!
+    }
+
+    override suspend fun process(update: Update) {
+        val update = update as? MessageUpdate ?: return
+        val message = update.data as? ContentMessage<*> ?: return
+        val content = message.content as? TextContent ?: return
+
+        val monetaryAmounts = monetaryAmountParsingPipeline.parse(content.text)
+
+        logger.debug("Parsed monetary amounts: {}", monetaryAmounts)
+
+        val conversions = targetCurrencies.flatMap { to ->
+            monetaryAmounts.mapNotNull {
+                exchangeRateClient.convert(it.amount, it.currency, to)
+            }
+        }.groupBy { it.query.amount to it.query.from }
+
+        val reply = conversions
+            .map { (query, conversions) ->
+                val (amount, from) = query
+                val results = conversions
+                    .sortedBy { it.query.to }
+                    .joinToString(", ") { "%.2f %s".format(it.result, it.query.to).escapeMarkdownV2Common() }
+
+                "**${"%.0f %s".format(amount, from).escapeMarkdownV2Common()}**: %s".format(results)
+            }
+            .joinToString("\n")
+
+        if (reply.isNotEmpty()) {
+            bot.reply(to = message, text = reply, parseMode = MarkdownV2ParseMode)
+        }
+    }
+}

currencies/src/main/kotlin/by/jprof/telegram/bot/currencies/model/MonetaryAmount.kt

@@ -0,0 +1,6 @@
+package by.jprof.telegram.bot.currencies.model
+
+data class MonetaryAmount(
+    val amount: Double,
+    val currency: String,
+)

currencies/src/main/kotlin/by/jprof/telegram/bot/currencies/parser/CAD.kt

@@ -0,0 +1,8 @@
+package by.jprof.telegram.bot.currencies.parser
+
+
+class CAD : MonetaryAmountParserBase() {
+    override val currency: String = "CAD"
+
+    override val currencyRegex: String = "(CAD|CA$|Can$|C$)"
+}

currencies/src/main/kotlin/by/jprof/telegram/bot/currencies/parser/GBP.kt

@@ -0,0 +1,7 @@
+package by.jprof.telegram.bot.currencies.parser
+
+class GBP : MonetaryAmountParserBase() {
+    override val currency: String = "GBP"
+
+    override val currencyRegex: String = "(GBP|£|POUND|ФУНТ|ФУНТОВ)"
+}

currencies/src/main/kotlin/by/jprof/telegram/bot/currencies/parser/GEL.kt

@@ -0,0 +1,8 @@
+package by.jprof.telegram.bot.currencies.parser
+
+class GEL : MonetaryAmountParserBase() {
+    override val currency: String = "GEL"
+
+    override val currencyRegex: String = "(GEL|₾|ლ|ЛАРИ)"
+}
+

currencies/src/main/kotlin/by/jprof/telegram/bot/currencies/parser/HRK.kt

@@ -0,0 +1,7 @@
+package by.jprof.telegram.bot.currencies.parser
+
+class HRK : MonetaryAmountParserBase() {
+    override val currency: String = "HRK"
+
+    override val currencyRegex: String = "(HRK|KN|KUNA|KUN|КУН)"
+}

currencies/src/main/kotlin/by/jprof/telegram/bot/currencies/parser/MonetaryAmountParser.kt

@@ -0,0 +1,5 @@
+package by.jprof.telegram.bot.currencies.parser
+
+import by.jprof.telegram.bot.currencies.model.MonetaryAmount
+
+typealias MonetaryAmountParser = (String) -> Set<MonetaryAmount>

currencies/src/main/kotlin/by/jprof/telegram/bot/currencies/parser/MonetaryAmountParserBase.kt

@@ -0,0 +1,52 @@
+package by.jprof.telegram.bot.currencies.parser
+
+import by.jprof.telegram.bot.currencies.model.MonetaryAmount
+
+abstract class MonetaryAmountParserBase : MonetaryAmountParser {
+    companion object {
+        private const val RANGE = "(-|–|—|―|‒|\\.\\.|\\.\\.\\.|…)"
+    }
+
+    override fun invoke(message: String): Set<MonetaryAmount> {
+        return (
+            listOf(r1, r2)
+                .flatMap { it.findAll(message) }
+                .mapNotNull {
+                    val rawAmount = it.groups["amount"]?.value ?: return@mapNotNull null
+                    val isK = it.groups["K"] != null
+                    val isM = it.groups["M"] != null
+                    val amount = rawAmount.toDouble().run { if (isK) this * 1000 else if (isM) this * 1000000 else this }
+
+                    MonetaryAmount(amount, currency)
+                } + listOf(r3, r4)
+                .flatMap { it.findAll(message) }
+                .mapNotNull {
+                    val rawAmount1 = it.groups["amount1"]?.value ?: return@mapNotNull null
+                    val rawAmount2 = it.groups["amount2"]?.value ?: return@mapNotNull null
+                    val isK = it.groups["K1"] != null || it.groups["K2"] != null
+                    val isM = it.groups["M1"] != null || it.groups["M2"] != null
+
+                    val amount1 = rawAmount1.toDouble().run { if (isK) this * 1000 else if (isM) this * 1000000 else this }
+                    val amount2 = rawAmount2.toDouble().run { if (isK) this * 1000 else if (isM) this * 1000000 else this }
+
+                    listOf(MonetaryAmount(amount1, currency), MonetaryAmount(amount2, currency))
+                }.flatten()
+            ).toSet()
+    }
+
+    protected abstract val currency: String
+
+    protected abstract val currencyRegex: String
+
+    private fun amount(index: Int? = null): String = "(?<amount${index ?: ""}>(\\d+\\.\\d+)|(\\d+))( *(?<K${index ?: ""}>[КK])|(?<M${index ?: ""}>[МM]))?"
+
+    private val r1 get() = "${amount()} *$currencyRegex".toRegex()
+
+    private val r2 get() = "$currencyRegex *${amount()}".toRegex()
+
+    private val r3 get() = "${amount(1)} *$RANGE *${amount(2)} *$currencyRegex".toRegex()
+
+    private val r4 get() = "$currencyRegex *${amount(1)} *$RANGE *${amount(2)}".toRegex()
+
+    private fun String.toRegex() = this.toRegex(RegexOption.IGNORE_CASE)
+}