"
55 | easterEggInputQueueProgress = 0
56 | }
57 | }
58 | }
59 |
60 | LaunchedEffect(Unit) {
61 | // Shitty hack to fix 100vh excluding URL bar on mobile devices, see: https://stackoverflow.com/questions/52848856/100vh-height-when-address-bar-is-shown-chrome-mobile
62 | (window.document.documentElement as HTMLElement).style.setProperty("--vh", "${window.innerHeight.toDouble() / 100}px")
63 |
64 | window.onresize = {
65 | (window.document.documentElement as HTMLElement).style.setProperty("--vh", "${window.innerHeight.toDouble() / 100}px")
66 | }
67 | }
68 |
69 | Style(Styles)
70 |
71 | Div(attrs = { classes(Styles.rootElement) }) {
72 | NotificationDisplay(
73 | notificationQueue = notificationQueue
74 | )
75 |
76 | MenuBox(
77 | achievementCompletionMap = achievementCompletionMap
78 | )
79 |
80 | Markov(
81 | talking = talking,
82 | muted = muted
83 | )
84 |
85 | ChatMessages(
86 | messages = messages,
87 | muted = muted,
88 | onMutedChanged = {
89 | muted = it
90 | },
91 | achievementCompletionMap = achievementCompletionMap
92 | )
93 |
94 | ChatInput(
95 | onMessageSent = { message ->
96 | messages = messages + ChatMessage(
97 | owner = ChatMessage.Owner.User,
98 | content = ChatMessage.Content.Text(message)
99 | )
100 |
101 | delay(0.5.seconds)
102 |
103 | val messagesBeforeAnswer = messages
104 |
105 | messages = messagesBeforeAnswer + ChatMessage(
106 | owner = ChatMessage.Owner.Markov,
107 | content = ChatMessage.Content.Loading
108 | )
109 |
110 | delay(1.seconds)
111 |
112 | try {
113 | val response = withTimeout(10.seconds) {
114 | httpClient.get(if ("localhost" in window.location.href) "http://localhost:7777/api/v1/query?input=$message" else "/api/v1/query?input=$message").let {
115 | if (it.status.isSuccess()) {
116 | it.body
()
117 | } else {
118 | throw MarkovBackendException(it.body())
119 | }
120 | }
121 | }
122 |
123 | val ttsResponse = if (!muted) {
124 | withTimeout(10.seconds) {
125 | httpClient.get("https://api.streamelements.com/kappa/v2/speech") {
126 | parameter("voice", "Brian")
127 | parameter("text", response)
128 | }.also {
129 | check(it.status.isSuccess()) { it.bodyAsText() }
130 | }
131 | }
132 | } else {
133 | null
134 | }
135 |
136 | for (achievement in achievements) {
137 | if (
138 | when (achievement.matcher) {
139 | is Achievement.Matcher.KeywordList -> achievement.matcher.keywords.any { it in response.lowercase() && it !in message.lowercase() }
140 | is Achievement.Matcher.Lambda -> achievement.matcher.matcher(message, response)
141 | is Achievement.Matcher.Regex -> achievement.matcher.regex.containsMatchIn(response.lowercase()) && !achievement.matcher.regex.containsMatchIn(message.lowercase())
142 | }
143 | && achievement.id !in achievementCompletionMap
144 | ) {
145 | achievementCompletionMap[achievement.id] = CompletedAchievement(
146 | instant = Clock.System.now(),
147 | query = message,
148 | response = response
149 | )
150 |
151 | console.log("Message \"$message\" with response \"$response\" rewarded user with achievement \"${achievement.name}\".")
152 | notificationQueue.tryEmit("Achievement unlocked: ${achievement.name}")
153 | }
154 | }
155 |
156 | messages = messagesBeforeAnswer + ChatMessage(
157 | owner = ChatMessage.Owner.Markov,
158 | content = ChatMessage.Content.Text(response)
159 | )
160 |
161 | talking = true
162 |
163 | if (ttsResponse != null) {
164 | val audio = Audio(URL.createObjectURL(Blob(arrayOf(ttsResponse.readBytes()), BlobPropertyBag(type = "audio/mpeg"))))
165 |
166 | suspendCoroutine {
167 | var cancelled = false
168 |
169 | val scope = CoroutineScope(Dispatchers.Main)
170 |
171 | val muteListener = scope.launch {
172 | while (isActive) {
173 | if (muted) {
174 | cancelled = true
175 | it.resume(Unit)
176 | audio.pause()
177 |
178 | break
179 | }
180 |
181 | delay(100.milliseconds)
182 | }
183 | }
184 |
185 | audio.onended = {
186 | if (!cancelled) {
187 | scope.launch {
188 | muteListener.cancelAndJoin()
189 | }
190 |
191 | it.resume(Unit)
192 | }
193 | }
194 |
195 | audio.play()
196 | }
197 | }
198 |
199 | true
200 | } catch (e: MarkovBackendException) {
201 | console.error("Backend error while requesting response:", e)
202 |
203 | messages = messagesBeforeAnswer + ChatMessage(
204 | owner = ChatMessage.Owner.Markov,
205 | content = ChatMessage.Content.Error(e.information)
206 | )
207 |
208 | false
209 | } catch (e: Exception) {
210 | console.error("Error while requesting response:", e)
211 |
212 | messages = messagesBeforeAnswer + ChatMessage(
213 | owner = ChatMessage.Owner.Markov,
214 | content = ChatMessage.Content.Error("Could not fetch response.")
215 | )
216 |
217 | false
218 | } finally {
219 | talking = false
220 | }
221 | }
222 | )
223 | }
224 | }
225 |
226 | class MarkovBackendException(val information: String) : Exception()
--------------------------------------------------------------------------------
/src/jsMain/kotlin/Achievements.kt:
--------------------------------------------------------------------------------
1 | import kotlinx.datetime.Instant
2 | import kotlinx.serialization.Serializable
3 |
4 | data class Achievement(
5 | val id: Int,
6 | val name: String,
7 | val description: String,
8 | val matcher: Matcher
9 | ) {
10 | sealed interface Matcher {
11 | data class KeywordList(val keywords: List) : Matcher
12 | data class Regex(val regex: kotlin.text.Regex) : Matcher
13 | data class Lambda(val matcher: (input: String, output: String) -> Boolean) : Matcher
14 | }
15 | }
16 |
17 | @Serializable
18 | data class CompletedAchievement(
19 | val instant: Instant,
20 | val query: String,
21 | val response: String
22 | )
23 |
24 | private val lightningEmotes = listOf("\uD83C\uDF29", "\u26A1")
25 |
26 | val achievements = listOf(
27 | Achievement(
28 | id = 1,
29 | name = "Capybara",
30 | description = "Make Markov mention capybaras",
31 | matcher = Achievement.Matcher.KeywordList(listOf("capybara"))
32 | ),
33 | Achievement(
34 | id = 2,
35 | name = "xqcL",
36 | description = "Make Markov mention xQc",
37 | matcher = Achievement.Matcher.KeywordList(listOf("xqc"))
38 | ),
39 | Achievement(
40 | id = 3,
41 | name = "CV Paste",
42 | description = "Have Markov copy your message",
43 | matcher = Achievement.Matcher.Lambda { input, output ->
44 | input == output
45 | }
46 | ),
47 | Achievement(
48 | id = 4,
49 | name = "Forsen Related",
50 | description = "Make Markov use the word \"forsen\" at least 20 times in one response",
51 | matcher = Achievement.Matcher.Lambda { input, output ->
52 | output.lowercase().split(Regex("\\bforsen\\b")).size >= 21 && "forsen forsen" !in input.lowercase()
53 | }
54 | ),
55 | Achievement(
56 | id = 5,
57 | name = "+20 Social Credit Points",
58 | description = "Make Markov speak Chinese",
59 | matcher = Achievement.Matcher.Regex(Regex("[\\u4e00-\\u9fff]"))
60 | ),
61 | Achievement(
62 | id = 6,
63 | name = "Arigato",
64 | description = "Make Markov speak Japanese",
65 | matcher = Achievement.Matcher.Regex(Regex("[\\u3040-\\u309f]"))
66 | ),
67 | Achievement(
68 | id = 7,
69 | name = "Cyka Blyat",
70 | description = "Make Markov speak Russian",
71 | matcher = Achievement.Matcher.Regex(Regex("[\\u0400-\\u04ff]"))
72 | ),
73 | Achievement(
74 | id = 8,
75 | name = "Halal",
76 | description = "Make Markov speak Arabic",
77 | matcher = Achievement.Matcher.Regex(Regex("[\\u0600-\\u06ff]"))
78 | ),
79 | Achievement(
80 | id = 9,
81 | name = "TÜRKIYE 💪",
82 | description = "Make Markov speak Turkish",
83 | matcher = Achievement.Matcher.Regex(Regex("[\\u011f\\u0131\\u015f]"))
84 | ),
85 | Achievement(
86 | id = 10,
87 | name = ":tf: 🤜 🔔",
88 | description = "Make Markov ping someone",
89 | matcher = Achievement.Matcher.KeywordList(listOf("u/"))
90 | ),
91 | Achievement(
92 | id = 11,
93 | name = "Please clarify",
94 | description = "Make Markov ping u/TheSeaHorseHS",
95 | matcher = Achievement.Matcher.KeywordList(listOf("u/theseahorsehs"))
96 | ),
97 | Achievement(
98 | id = 12,
99 | name = "uwu",
100 | description = "Make Markov ping u/Furry_Degen",
101 | matcher = Achievement.Matcher.KeywordList(listOf("u/furry_degen"))
102 | ),
103 | Achievement(
104 | id = 13,
105 | name = "Not Suge Knight",
106 | description = "Make Markov talk about shungite",
107 | matcher = Achievement.Matcher.KeywordList(listOf("shungite"))
108 | ),
109 | Achievement(
110 | id = 14,
111 | name = "Kinda Snus",
112 | description = "Make Markov mention something Among Us related",
113 | matcher = Achievement.Matcher.KeywordList(listOf("among us", "amogus", "amonge", "sus ", "sussy", "crewmate", "impostor", "imposter", "emergency meeting", "ඞ"))
114 | ),
115 | Achievement(
116 | id = 15,
117 | name = "forsen",
118 | description = "Make Markov use a singular \"forsen\" as a response",
119 | matcher = Achievement.Matcher.Lambda { _, output ->
120 | output == "forsen"
121 | }
122 | ),
123 | Achievement(
124 | id = 16,
125 | name = "MrDestructoid",
126 | description = "Make Markov speak binary",
127 | matcher = Achievement.Matcher.Regex(Regex("\\b[01]{8}\\b"))
128 | ),
129 | Achievement(
130 | id = 17,
131 | name = "Concerned",
132 | description = "Make Markov ask if you have any questions or concerns",
133 | matcher = Achievement.Matcher.KeywordList(listOf("you have any questions or concerns"))
134 | ),
135 | Achievement(
136 | id = 18,
137 | name = "forsenCD",
138 | description = "Make Markov give you a completely transparent response",
139 | matcher = Achievement.Matcher.Regex(Regex("^\\u200b$"))
140 | ),
141 | Achievement(
142 | id = 19,
143 | name = "fr fr ong",
144 | description = "Make Markov say zoomer shit",
145 | matcher = Achievement.Matcher.Regex(Regex("\\bfr\\b|\\bong\\b|on god|deadass|bussin|no cap|goated"))
146 | ),
147 | Achievement(
148 | id = 20,
149 | name = "YOURMOM",
150 | description = "Make Markov talk about your mother",
151 | matcher = Achievement.Matcher.KeywordList(listOf("your mom", "your mother", "your mum"))
152 | ),
153 | Achievement(
154 | id = 21,
155 | name = "Different people Copesen",
156 | description = "Make Markov mention Gura",
157 | matcher = Achievement.Matcher.KeywordList(listOf("gura"))
158 | ),
159 | Achievement(
160 | id = 22,
161 | name = "forsenLevel",
162 | description = "Make Markov level",
163 | matcher = Achievement.Matcher.KeywordList(listOf("forsenlevel"))
164 | ),
165 | Achievement(
166 | id = 23,
167 | name = "Arcane",
168 | description = "Make Markov talk about Arcane",
169 | matcher = Achievement.Matcher.KeywordList(listOf("caitlyn", "jinx", "arcane"))
170 | ),
171 | Achievement(
172 | id = 24,
173 | name = "BatChest",
174 | description = "Make Markov bat IRL",
175 | matcher = Achievement.Matcher.KeywordList(listOf("marvel", "thanos", "batchest"))
176 | ),
177 | Achievement(
178 | id = 25,
179 | name = "FUCK♂YOU",
180 | description = "Make Markov talk about Gachi",
181 | matcher = Achievement.Matcher.KeywordList(listOf("gachi", "billy herrington"))
182 | ),
183 | Achievement(
184 | id = 26,
185 | name = "💦",
186 | description = "Make Markov coom to something",
187 | matcher = Achievement.Matcher.KeywordList(listOf("forsencoomer"))
188 | ),
189 | Achievement(
190 | id = 27,
191 | name = "NURSE??? 🔔",
192 | description = "Make Markov suggest that you take your pills",
193 | matcher = Achievement.Matcher.Regex(Regex("take (?:your|my|the) (?:fucking? )?(?:pills|meds|medicine)"))
194 | ),
195 | Achievement(
196 | id = 28,
197 | name = "You Should ...",
198 | description = "Make Markov use both the \uD83C\uDF29 (thunderstorm) emoji as well as \"NOW\" in the same response",
199 | matcher = Achievement.Matcher.Lambda { input, output ->
200 | lightningEmotes.any { it in output } && "NOW" in output && lightningEmotes.none { it in input } && "NOW" !in input
201 | }
202 | ),
203 | Achievement(
204 | id = 29,
205 | name = "Punk Kid",
206 | description = "Make Markov post the Among Us crewmate cock copypasta",
207 | matcher = Achievement.Matcher.KeywordList(listOf("⣿⣿⣿⠟⢹⣶⣶⣝⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿"))
208 | ),
209 | Achievement(
210 | id = 30,
211 | name = "monkaLaugh",
212 | description = "Make Markov mention Hitler",
213 | matcher = Achievement.Matcher.KeywordList(listOf("hitler"))
214 | ),
215 | Achievement(
216 | id = 31,
217 | name = "The Witch",
218 | description = "Make Markov mention N̵̨̮͉̟̣̥̰̫̹̣̱̩̭̦̿̅̆̈́̌́̍̾́͆͒̄̒̚̚i̷̧̩̯͖̖͎̱̹̿̓̈́̑̐͗͂̓́̇̕͠ņ̶̡̠̞̖͓͓̹̳̦̞͍̈̔̈́̉̀́̓͗̕͜a̴̡̨̫̤͈̳̜̺̩̗̗̖̼̖͔̍̅͑͋̈́͑̾̾̽̍̈́̚",
219 | matcher = Achievement.Matcher.Regex(Regex("\\bnina\\b|\\bnani\\b"))
220 | ),
221 | Achievement(
222 | id = 32,
223 | name = "Happy Birthday",
224 | description = "Make Markov wish you a happy birthday",
225 | matcher = Achievement.Matcher.KeywordList(listOf("happy birthday"))
226 | ),
227 | Achievement(
228 | id = 33,
229 | name = "eg?",
230 | description = "Make Markov talk about eggs",
231 | matcher = Achievement.Matcher.Regex(Regex("\uD83E\uDD5A|\\beg\\b|\\begg"))
232 | ),
233 | Achievement(
234 | id = 34,
235 | name = "MODS",
236 | description = "Make Markov say that he is chicken",
237 | matcher = Achievement.Matcher.KeywordList(listOf("i am chicken", "im chicken", "i'm chicken"))
238 | ),
239 | Achievement(
240 | id = 35,
241 | name = "Vi Sitter Här",
242 | description = "Make Markov rant about your Dota skills",
243 | matcher = Achievement.Matcher.Regex(Regex("(?:da|that)'?s a big problem|f[auo]king? tr[ea]sh|26 minute?|big r[ei]tard pl[ae]yer"))
244 | ),
245 | Achievement(
246 | id = 36,
247 | name = "Bruce U",
248 | description = "Make Markov mention Uganda or Uganda related topics",
249 | matcher = Achievement.Matcher.KeywordList(listOf("uganda", "wakaliwood", "captain alex", "tiger mafia", "bruce u", "pastor lul"))
250 | ),
251 | )
--------------------------------------------------------------------------------
/src/jvmMain/kotlin/backend/JanitorBackend.kt:
--------------------------------------------------------------------------------
1 | package backend
2 |
3 | import io.ktor.http.*
4 | import io.ktor.resources.*
5 | import io.ktor.server.application.*
6 | import io.ktor.server.auth.*
7 | import io.ktor.server.html.*
8 | import io.ktor.server.resources.*
9 | import io.ktor.server.response.*
10 | import io.ktor.server.sessions.*
11 | import io.ktor.util.pipeline.*
12 | import kotlinx.css.*
13 | import kotlinx.css.properties.TextDecoration
14 | import kotlinx.css.properties.TextDecorationLine
15 | import kotlinx.datetime.Clock
16 | import kotlinx.datetime.Instant
17 | import kotlinx.datetime.toJavaInstant
18 | import kotlinx.datetime.toKotlinInstant
19 | import kotlinx.html.*
20 | import net.dean.jraw.RedditClient
21 | import net.dean.jraw.http.OkHttpNetworkAdapter
22 | import net.dean.jraw.http.UserAgent
23 | import net.dean.jraw.models.Comment
24 | import net.dean.jraw.models.Listing
25 | import net.dean.jraw.models.OAuthData
26 | import net.dean.jraw.oauth.Credentials
27 | import net.dean.jraw.oauth.NoopTokenStore
28 | import java.util.*
29 | import kotlin.time.Duration.Companion.days
30 | import kotlin.time.Duration.Companion.seconds
31 |
32 | private suspend fun ApplicationCall.respondReturnToLogin() {
33 | respondHtml {
34 | head {
35 | title("Invalid Reddit Login")
36 | styleLink(application.run { href(Routes.JanitorBackend.StylesCss()) })
37 | }
38 |
39 | body {
40 | p {
41 | +"Invalid Reddit login."
42 | }
43 |
44 | br { }
45 |
46 | a(href = "/") {
47 | +"Return to login"
48 | }
49 | }
50 | }
51 | }
52 |
53 | private fun setupRedditClient(session: Session, validateUser: Boolean = true): RedditClient? {
54 | val userAgent = UserAgent(
55 | platform = "JVM/JRAW",
56 | appId = "${RuntimeVariables.Reddit.botAppId} Comment Sanitation and Waste Management Engineer Duties",
57 | version = BuildInfo.PROJECT_VERSION,
58 | redditUsername = RuntimeVariables.Reddit.botAuthorRedditUsername
59 | )
60 |
61 | val redditClient = RedditClient::class.constructors.first().call(
62 | OkHttpNetworkAdapter(userAgent),
63 | OAuthData.create(session.redditAccessToken, listOf("identity"), session.redditRefreshToken, Date.from(session.redditAccessTokenExpiration.toJavaInstant())),
64 | Credentials.webapp(
65 | clientId = RuntimeVariables.Backend.redditClientId,
66 | clientSecret = RuntimeVariables.Backend.redditClientSecret,
67 | redirectUrl = redditLoginRedirectUrl
68 | ),
69 | NoopTokenStore(),
70 | null
71 | ).apply {
72 | logHttp = false
73 | }
74 |
75 | return if (redditClient.me().username.lowercase() in RuntimeVariables.Backend.permittedUsers || !validateUser) {
76 | redditClient
77 | } else {
78 | null
79 | }
80 | }
81 |
82 | suspend fun PipelineContext.janitorBackendLogin() {
83 | call.respondHtml {
84 | head {
85 | title("MarkovBaj Janitor Backend Login")
86 | styleLink(application.run { href(Routes.JanitorBackend.StylesCss()) })
87 | }
88 |
89 | body {
90 | button {
91 | onClick = "location.href = '${application.run { href(Routes.JanitorBackend.Login()) }}'"
92 |
93 | +"Login"
94 | }
95 |
96 | footer {
97 | +"Version ${BuildInfo.PROJECT_VERSION}, Build ${Instant.fromEpochMilliseconds(BuildInfo.PROJECT_BUILD_TIMESTAMP_MILLIS)}"
98 | }
99 | }
100 | }
101 | }
102 |
103 | suspend fun PipelineContext.janitorBackendCallback() {
104 | val principal = call.authentication.principal() ?: run {
105 | call.respondReturnToLogin()
106 | return
107 | }
108 |
109 | val newSession = Session(
110 | redditAccessToken = principal.accessToken,
111 | redditRefreshToken = principal.refreshToken,
112 | redditAccessTokenExpiration = Clock.System.now() + principal.expiresIn.seconds
113 | )
114 |
115 | val userRedditClientName = setupRedditClient(newSession, validateUser = false)!!.me().username
116 |
117 | if (userRedditClientName.lowercase() in RuntimeVariables.Backend.permittedUsers) {
118 | logger.info { "User '$userRedditClientName' has logged into the janitor backend." }
119 | call.sessions.set(newSession)
120 | } else {
121 | logger.info { "User '$userRedditClientName' has tried to log into the janitor backend, but isn't permitted to do so." }
122 | }
123 |
124 | call.respondRedirect(application.run { href(Routes.JanitorBackend.Manage()) })
125 | }
126 |
127 | suspend fun PipelineContext.janitorBackendManage() {
128 | val session = call.sessions.get() ?: run {
129 | call.respondReturnToLogin()
130 | return
131 | }
132 |
133 | val userRedditClient = setupRedditClient(session) ?: run {
134 | call.respondReturnToLogin()
135 | return
136 | }
137 |
138 | call.respondHtml {
139 | head {
140 | title("MarkovBaj Janitor Backend")
141 | styleLink(application.run { href(Routes.JanitorBackend.StylesCss()) })
142 | }
143 |
144 | body {
145 | img {
146 | src = "https://styles.redditmedia.com/t5_4wpxrc/styles/profileIcon_1ypmzxwn0hn71.png?width=256&height=256&crop=256:256,smart&s=da81d12487728dfa78e33f9ae2af8a5df87ee317"
147 | }
148 |
149 | p {
150 | +"Hello /u/${userRedditClient.me().username}, welcome to the "
151 | span(classes = "strikethrough") { +"Janitor Room" }
152 | +" MarkovBaj Comment Sanitation and Waste Management Engineer Duties Centre."
153 | }
154 |
155 | br { }
156 |
157 | form(action = call.application.href(Routes.JanitorBackend.DeleteComment(commentLink = "")), method = FormMethod.get) {
158 | h1 {
159 | +"Comment deleter"
160 | }
161 |
162 | p {
163 | +"Only comments with a maximum age of 24 hours can be deleted. Only delete TOS comments. Deletions will be logged. Link can be obtained with Share -> Copy Link."
164 | }
165 |
166 | input {
167 | type = InputType.text
168 | name = "comment_link"
169 | placeholder = "Direct comment perma link (e.g. https://www.reddit.com/r/forsen/comments/pgamez/mods_update/hbbiwe7/)"
170 | }
171 |
172 | input {
173 | type = InputType.submit
174 | value = "Delete"
175 | }
176 | }
177 | }
178 | }
179 | }
180 |
181 | suspend fun PipelineContext.janitorBackendDeleteComment(redditClient: RedditClient?, deleteCommentRequest: Routes.JanitorBackend.DeleteComment) {
182 | val session = call.sessions.get() ?: run {
183 | call.respondReturnToLogin()
184 | return
185 | }
186 |
187 | val userRedditClientName = setupRedditClient(session)?.me()?.username ?: run {
188 | call.respondReturnToLogin()
189 | return
190 | }
191 |
192 | if (redditClient == null) {
193 | call.respondText("Unable to delete comment because Reddit bot is not set up.")
194 | return
195 | }
196 |
197 | try {
198 | val pathSegments = Url(deleteCommentRequest.commentLink).pathSegments
199 |
200 | val commentToDelete = @Suppress("UNCHECKED_CAST") (redditClient.lookup("t1_${pathSegments[6]}") as Listing)
201 | .children
202 | .first()
203 |
204 | if ((Clock.System.now() - commentToDelete.created.toInstant().toKotlinInstant() - 1.days).isPositive()) {
205 | call.respondText("Comment is too old to be deleted.", status = HttpStatusCode.BadRequest)
206 | return
207 | }
208 |
209 | if (commentToDelete.author.lowercase() != RuntimeVariables.Reddit.botUsername.lowercase()) {
210 | call.respondText("Comment was not posted by authenticated account.", status = HttpStatusCode.BadRequest)
211 | return
212 | }
213 |
214 | redditClient.comment(pathSegments[6]).delete()
215 | logger.info { "Comment '${pathSegments[6]}' at '${deleteCommentRequest.commentLink}' with the content '${commentToDelete.body}' was deleted by user '${userRedditClientName}'." }
216 | call.respondText("Comment was deleted.")
217 | } catch (e: Exception) {
218 | call.respondText("Invalid comment URL.", status = HttpStatusCode.BadRequest)
219 | logger.warn { "Comment deletion by '$userRedditClientName' failed: $e" }
220 | return
221 | }
222 | }
223 |
224 | suspend fun PipelineContext.janitorBackendStyles() {
225 | call.respondText(
226 | text = CssBuilder().apply {
227 | rule("body") {
228 | width = 800.px
229 | paddingTop = 50.px
230 | margin(LinearDimension.auto)
231 | fontFamily = "Arial"
232 | }
233 |
234 | rule("body *") {
235 | width = 100.pct
236 | boxSizing = BoxSizing.borderBox
237 | }
238 |
239 | rule("footer") {
240 | position = Position.fixed
241 | bottom = 0.px
242 | padding(16.px)
243 | }
244 |
245 | rule("button") {
246 | height = 48.px
247 | }
248 |
249 | rule("input[type=\"text\"], input[type=\"submit\"]") {
250 | marginTop = 8.px
251 | padding(8.px)
252 | }
253 |
254 | rule("img") {
255 | width = 256.px
256 | display = Display.block
257 | margin(LinearDimension.auto)
258 | }
259 |
260 | rule(".strikethrough") {
261 | textDecoration = TextDecoration(setOf(TextDecorationLine.lineThrough))
262 | }
263 | }.toString(),
264 | contentType = ContentType.Text.CSS
265 | )
266 | }
--------------------------------------------------------------------------------
/src/jsMain/kotlin/Styles.kt:
--------------------------------------------------------------------------------
1 | import org.jetbrains.compose.web.css.*
2 |
3 | object Styles : StyleSheet() {
4 | val bodyPadding = 16.px
5 |
6 |
7 | init {
8 | "body" style {
9 | margin(0.px)
10 | backgroundImage("url('img/background.webp')")
11 | backgroundRepeat("repeat")
12 | backgroundSize("contain")
13 | color(Color.white)
14 | property("overscroll-behavior", "contain")
15 | }
16 |
17 | "::-webkit-scrollbar" style {
18 | display(DisplayStyle.None)
19 | }
20 |
21 | "input:focus" style {
22 | outline("none")
23 | }
24 | }
25 |
26 |
27 | val rootElement by style {
28 | position(Position.Relative)
29 |
30 | width(100.percent)
31 | maxWidth(768.px)
32 | height(100.vh)
33 |
34 | // Shitty hack to fix 100vh excluding URL bar on mobile devices, see: https://stackoverflow.com/questions/52848856/100vh-height-when-address-bar-is-shown-chrome-mobile
35 | property("height", "calc(var(--vh, 1vh) * 100)")
36 |
37 | property("margin", "auto")
38 | padding(bodyPadding)
39 |
40 | display(DisplayStyle.Flex)
41 | flexDirection(FlexDirection.Column)
42 |
43 | boxSizing("border-box")
44 | fontFamily("Consolas", "monospace")
45 | }
46 |
47 | val hidden by style {
48 | opacity(0)
49 | }
50 |
51 | val smallBorderContainer by style {
52 | display(DisplayStyle.Grid)
53 | gridTemplateColumns("20px auto 20px")
54 | gridTemplateRows("15px auto 15px")
55 | width(100.percent)
56 | }
57 |
58 | val smallBorderHorizontalImage by style {
59 | width(100.percent)
60 | height(69.px)
61 | }
62 |
63 | val notificationContainer by style {
64 | position(Position.Absolute)
65 | left(64.px)
66 | right(128.px)
67 | backgroundColor(rgba(50, 50, 50, 0.8))
68 | display(DisplayStyle.Flex)
69 | justifyItems("center")
70 | }
71 |
72 | val notificationInnerContainer by style {
73 | property("z-index", 3)
74 | }
75 |
76 | val notificationBackground by style {
77 | position(Position.Absolute)
78 | left(10.px)
79 | right(10.px)
80 | top(10.px)
81 | bottom(10.px)
82 | backgroundColor(rgb(60, 60, 60))
83 | property("z-index", 3)
84 | }
85 |
86 | val notificationContent by style {
87 | fontSize(16.px)
88 | gridColumn("2")
89 | gridRow("2")
90 | property("z-index", 3)
91 | display(DisplayStyle.Flex)
92 | alignItems(AlignItems.Center)
93 | }
94 |
95 | val menuButton by style {
96 | position(Position.Absolute)
97 | right(bodyPadding)
98 | padding(8.px)
99 | property("z-index", 1)
100 | property("border", "none")
101 | backgroundColor(rgb(30, 30, 30))
102 | borderRadius(bottomLeft = 8.px, bottomRight = 8.px, topLeft = 0.px, topRight = 0.px)
103 | cursor("pointer")
104 | }
105 |
106 | val menuButtonIcon by style {
107 | width(36.px)
108 | }
109 |
110 | val menuContainer by style {
111 | position(Position.Absolute)
112 | display(DisplayStyle.Flex)
113 | height(40.vh)
114 | left(0.px)
115 | right(0.px)
116 | padding(16.px)
117 | backgroundColor(rgba(20, 20, 20, 0.9))
118 | property("z-index", 1)
119 | flexWrap(FlexWrap.Wrap)
120 | property("place-content", "flex-start")
121 | justifyContent(JustifyContent.SpaceBetween)
122 | overflowY("scroll")
123 | boxSizing("border-box")
124 | color(Color.white)
125 | borderRadius(bottomLeft = 8.px, bottomRight = 8.px, topLeft = 0.px, topRight = 0.px)
126 | }
127 |
128 | val menuHeadline by style {
129 | flexBasis(100.percent)
130 | padding(16.px)
131 | textAlign("justify")
132 | fontSize(18.pt)
133 | marginBottom(0.px)
134 | }
135 |
136 | val menuText by style {
137 | flexBasis(100.percent)
138 | padding(16.px)
139 | paddingTop(0.px)
140 | textAlign("justify")
141 | fontSize(13.pt)
142 | }
143 |
144 | val creditsLine by style {
145 | flexBasis(100.percent)
146 | padding(16.px)
147 | paddingTop(0.px)
148 | paddingBottom(0.px)
149 | display(DisplayStyle.Flex)
150 | alignItems(AlignItems.Center)
151 | }
152 |
153 | val socialMediaIcon by style {
154 | marginTop(2.px)
155 | marginLeft(10.px)
156 | }
157 |
158 | val achievementContainer by style {
159 | display(DisplayStyle.Flex)
160 | margin(8.px)
161 | flexDirection(FlexDirection.Column)
162 | width(96.px)
163 | }
164 |
165 | val achievementIconContainer by style {
166 | width(100.percent)
167 | height(96.px)
168 | borderRadius(9.px)
169 | display(DisplayStyle.Flex)
170 | }
171 |
172 | val achievementIcon by style {
173 | width(100.percent)
174 | height(100.percent)
175 | borderRadius(8.px)
176 | }
177 |
178 | val achievementCaption by style {
179 | width(100.percent)
180 | paddingTop(8.px)
181 | textAlign("center")
182 | boxSizing("border-box")
183 | property("word-wrap", "break-word")
184 | fontSize(10.pt)
185 | }
186 |
187 | val markovContainer by style {
188 | position(Position.Relative)
189 | height(40.vh)
190 | }
191 |
192 | val markovBodyPart by style {
193 | position(Position.Absolute)
194 | width(100.percent)
195 | height(100.percent)
196 | property("object-fit", "contain")
197 | }
198 |
199 | val markovHeadPart by style {
200 | // animation(swayAnimation) {
201 | // duration(3.s)
202 | // timingFunction(AnimationTimingFunction.EaseInOut)
203 | // iterationCount(Int.MAX_VALUE)
204 | // direction(AnimationDirection.Alternate)
205 | // }
206 | //
207 | // animation(bobAnimation) {
208 | // duration(1.1.s)
209 | // timingFunction(AnimationTimingFunction.EaseInOut)
210 | // iterationCount(Int.MAX_VALUE)
211 | // direction(AnimationDirection.Alternate)
212 | // }
213 | }
214 |
215 | // val swayAnimation by keyframes {
216 | // from {
217 | // marginLeft((-1).percent)
218 | // }
219 | //
220 | // to {
221 | // marginTop(1.percent)
222 | // }
223 | // }
224 | //
225 | // val bobAnimation by keyframes {
226 | // from {
227 | // marginTop((-0.3).percent)
228 | // }
229 | //
230 | // to {
231 | // marginTop(0.3.percent)
232 | // }
233 | // }
234 |
235 | val chatContainer by style {
236 | width(100.percent)
237 | height(100.percent)
238 | maxHeight(65.vh)
239 | flexShrink(1)
240 | position(Position.Relative)
241 | }
242 |
243 | val ttsMutedSettingContainer by style {
244 | position(Position.Absolute)
245 | top((-96).px)
246 | right(50.px)
247 | width(96.px)
248 | height(96.px)
249 | cursor("pointer")
250 | }
251 |
252 | val ttsMutedSettingIcon by style {
253 | position(Position.Absolute)
254 | width(96.px)
255 | height(96.px)
256 | }
257 |
258 | val achievementCompleteTrophyIcon by style {
259 | position(Position.Absolute)
260 | top((-96).px)
261 | left(40.px)
262 | width(96.px)
263 | height(96.px)
264 | cursor("pointer")
265 | }
266 |
267 | val chatBackground by style {
268 | position(Position.Absolute)
269 | left(20.px)
270 | right(20.px)
271 | top(20.px)
272 | bottom(20.px)
273 | backgroundColor(Color.black)
274 | property("z-index", -1)
275 | }
276 |
277 | val chatBorderContainer by style {
278 | width(100.percent)
279 | height(100.percent)
280 | display(DisplayStyle.Grid)
281 | gridTemplateColumns("75px auto 75px")
282 | gridTemplateRows("75px auto 75px")
283 | }
284 |
285 | val chatMessageContainer by style {
286 | width(100.percent)
287 | height(100.percent)
288 | display(DisplayStyle.Flex)
289 | flexDirection(FlexDirection.Column)
290 | overflow("scroll")
291 | gridColumn("2")
292 | gridRow("2")
293 | lineHeight("1.3")
294 | property("scrollbar-width", "none")
295 | }
296 |
297 | val chatBorderCorner by style {
298 | width(100.percent)
299 | }
300 |
301 | val chatMessage by style {
302 | fontSize(16.px)
303 | property("word-wrap", "break-word")
304 | paddingBottom(32.px)
305 | }
306 |
307 | val chatMessageConsoleUser by style {
308 | color(Color.lime)
309 | }
310 |
311 | val chatMessageConsoleMarkov by style {
312 | color(rgb(255, 40, 20))
313 | }
314 |
315 | val chatMessageConsoleLocation by style {
316 | color(Color.dodgerblue)
317 | }
318 |
319 | val chatMessageConsoleUnimportant by style {
320 | color(Color.lightgray)
321 | }
322 |
323 | val chatMessageError by style {
324 | color(rgb(0xcc, 0x00, 0x00))
325 | }
326 |
327 | val chatInputContainer by style {
328 | width(100.percent)
329 | position(Position.Relative)
330 | paddingLeft(8.px)
331 | paddingRight(8.px)
332 | marginTop(8.px)
333 | boxSizing("border-box")
334 | }
335 |
336 | val chatInputBackground by style {
337 | position(Position.Absolute)
338 | left(10.px)
339 | right(10.px)
340 | top(10.px)
341 | bottom(10.px)
342 | backgroundColor(Color.black)
343 | property("z-index", -1)
344 | }
345 |
346 | val chatInput by style {
347 | width(100.percent)
348 | backgroundColor(Color.transparent)
349 | property("border", "none")
350 | fontSize(16.px)
351 | paddingTop(10.px)
352 | paddingBottom(10.px)
353 | gridColumn("2")
354 | gridRow("2")
355 | boxSizing("border-box")
356 | fontFamily("Consolas", "monospace")
357 | color(Color.white)
358 | }
359 |
360 | val chatInputBorderContainer by style {
361 | width(100.percent)
362 | height(100.percent)
363 | }
364 | }
--------------------------------------------------------------------------------
/src/jvmMain/kotlin/RedditBot.kt:
--------------------------------------------------------------------------------
1 |
2 | import kotlinx.coroutines.coroutineScope
3 | import kotlinx.coroutines.delay
4 | import kotlinx.coroutines.flow.MutableSharedFlow
5 | import kotlinx.coroutines.isActive
6 | import kotlinx.coroutines.launch
7 | import kotlinx.datetime.Clock
8 | import kotlinx.datetime.toKotlinInstant
9 | import mu.KotlinLogging
10 | import net.dean.jraw.RedditClient
11 | import net.dean.jraw.http.OkHttpNetworkAdapter
12 | import net.dean.jraw.http.UserAgent
13 | import net.dean.jraw.models.SubredditSort
14 | import net.dean.jraw.oauth.Credentials
15 | import net.dean.jraw.oauth.OAuthHelper
16 | import net.dean.jraw.references.PublicContributionReference
17 | import kotlin.concurrent.fixedRateTimer
18 | import kotlin.time.Duration.Companion.hours
19 |
20 | private val logger = KotlinLogging.logger("MarkovBaj:Reddit")
21 |
22 | fun setupRedditClient(): RedditClient {
23 | val redditBotCredentials = Credentials.script(
24 | username = RuntimeVariables.Reddit.botUsername,
25 | password = RuntimeVariables.Reddit.botPassword,
26 | clientId = RuntimeVariables.Reddit.botClientId,
27 | clientSecret = RuntimeVariables.Reddit.botClientSecret
28 | )
29 |
30 | val userAgent = UserAgent(
31 | platform = "JVM/JRAW",
32 | appId = RuntimeVariables.Reddit.botAppId,
33 | version = BuildInfo.PROJECT_VERSION,
34 | redditUsername = RuntimeVariables.Reddit.botAuthorRedditUsername
35 | )
36 |
37 | val redditClient = OAuthHelper.automatic(OkHttpNetworkAdapter(userAgent), redditBotCredentials).apply {
38 | logHttp = false
39 | }
40 |
41 | logger.info("Connected to Reddit.")
42 |
43 | return redditClient
44 | }
45 |
46 | suspend fun setupRedditBot(redditClient: RedditClient, markovChain: MarkovChain, eventFlow: MutableSharedFlow) = coroutineScope {
47 | val activeSubreddit = redditClient.subreddit(RuntimeVariables.Reddit.activeSubreddit)
48 |
49 | var alreadyProcessedPostIds = listOf()
50 | var alreadyProcessedCommentsIds = listOf()
51 |
52 | logger.info("Bot running.")
53 |
54 | fixedRateTimer(period = RuntimeVariables.Reddit.checkInterval.inWholeMilliseconds) {
55 | launch {
56 | try {
57 | val newInboxMessages = redditClient.me()
58 | .inbox()
59 | .iterate("unread")
60 | .build()
61 | .accumulateMerged(1)
62 | .filter {
63 | it.subject == "username mention" ||
64 | it.subject.startsWith("comment reply") && CommonConstants.triggerKeyword.lowercase() in it.body.lowercase() && it.subreddit != RuntimeVariables.Reddit.activeSubreddit
65 | }
66 |
67 | val newPosts = activeSubreddit.posts()
68 | .sorting(SubredditSort.NEW)
69 | .limit(100)
70 | .build()
71 | .accumulateMerged(1)
72 | .filter { it.created.toInstant().toKotlinInstant() > Clock.System.now() - RuntimeVariables.Reddit.checkInterval * 5 && it.id !in alreadyProcessedPostIds }
73 |
74 | val newComments = activeSubreddit.comments()
75 | .limit(100)
76 | .build()
77 | .accumulateMerged(1)
78 | .filter {
79 | it.created.toInstant().toKotlinInstant() > Clock.System.now() - RuntimeVariables.Reddit.checkInterval * 2 &&
80 | it.id !in alreadyProcessedCommentsIds &&
81 | it.id !in newInboxMessages.filter { message -> message.subreddit == RuntimeVariables.Reddit.activeSubreddit }.map { message -> message.id }
82 | }
83 |
84 | logger.info("${newInboxMessages.size} new mention(s), ${newPosts.size} new post(s), ${newComments.size} new comment(s).")
85 |
86 | eventFlow.tryEmit(
87 | ApiEvent.CommentsCollected(
88 | comments = newComments.map { comment ->
89 | ApiEvent.CommentsCollected.Comment(
90 | id = comment.id,
91 | created = comment.created.toInstant().toKotlinInstant(),
92 | author = comment.author,
93 | body = comment.body,
94 | url = comment.url,
95 | authorFlairText = comment.authorFlairText,
96 | submissionFullName = comment.submissionFullName,
97 | submissionTitle = comment.submissionTitle,
98 | subredditType = comment.subredditType.name,
99 | distinguished = comment.distinguished.name,
100 | fullName = comment.fullName,
101 | parentFullName = comment.parentFullName,
102 | subredditFullName = comment.subredditFullName,
103 | )
104 | }
105 | )
106 | )
107 |
108 | eventFlow.tryEmit(
109 | ApiEvent.SubmissionsCollected(
110 | submissions = newPosts.map { post ->
111 | ApiEvent.SubmissionsCollected.Submission(
112 | created = post.created.toInstant().toKotlinInstant(),
113 | distinguished = post.distinguished.name,
114 | id = post.id,
115 | author = post.author,
116 | body = post.body,
117 | title = post.title,
118 | url = post.url,
119 | authorFlairText = post.authorFlairText,
120 | domain = post.domain,
121 | embeddedMedia = post.embeddedMedia != null,
122 | isNsfw = post.isNsfw,
123 | isSelfPost = post.isSelfPost,
124 | isSpoiler = post.isSpoiler,
125 | linkFlairCssClass = post.linkFlairCssClass,
126 | linkFlairText = post.linkFlairText,
127 | permalink = post.permalink,
128 | postHint = post.postHint,
129 | preview = post.preview != null,
130 | selfText = post.selfText,
131 | thumbnail = post.thumbnail,
132 | fullName = post.fullName,
133 | subreddit = post.subreddit,
134 | subredditFullName = post.subredditFullName,
135 | )
136 | }
137 | )
138 | )
139 |
140 | alreadyProcessedPostIds = newPosts.map { it.id }
141 | alreadyProcessedCommentsIds = newInboxMessages.map { it.id }.union(newComments.map { it.id }).toList()
142 |
143 | var commentCounter = 0
144 |
145 | if (RuntimeVariables.Reddit.answerMentions) {
146 | for (message in newInboxMessages) {
147 | if (commentCounter >= RuntimeVariables.Reddit.maxCommentsPerCheck) {
148 | logger.warn("Hit comment limit, not posting any more replies.")
149 | return@launch
150 | }
151 |
152 | if (!message.isComment) {
153 | logger.warn("Username mention with id ${message.id} was not a comment, skipping...")
154 | return@launch
155 | }
156 |
157 | val wordsInTitle = message.body.toWordParts()
158 |
159 | val relatedReply = if (Math.random() > RuntimeVariables.Common.unrelatedAnswerChance) {
160 | markovChain.tryGeneratingReplyFromWords(wordsInTitle, platform = "Reddit")
161 | } else {
162 | null
163 | }
164 |
165 | val actualReply = if (relatedReply != null) {
166 | logger.info("Replying to mention by ${message.author} in message ${message.id} in ${message.subreddit?.let { "r/$it" } ?: "-"} ('${message.body}') with related answer...")
167 | relatedReply
168 | } else {
169 | markovChain.generateRandomReply().also {
170 | logger.info("Default replying to mention by ${message.author} in message ${message.id} in ${message.subreddit?.let { "r/$it" } ?: "-"} ('${message.body}')...")
171 | }
172 | }
173 |
174 | redditClient.comment(message.id).safeReply(actualReply)
175 | redditClient.me().inbox().markRead(true, message.fullName)
176 | commentCounter++
177 |
178 | delay(RuntimeVariables.Reddit.delayBetweenComments)
179 | }
180 | }
181 |
182 | for (post in newPosts) {
183 | if (commentCounter >= RuntimeVariables.Reddit.maxCommentsPerCheck) {
184 | logger.warn("Hit comment limit, not posting any more replies.")
185 | return@launch
186 | }
187 |
188 | if (post.isRemoved) {
189 | continue
190 | }
191 |
192 | if (CommonConstants.triggerKeyword.lowercase() in post.title.lowercase()) {
193 | val wordsInTitle = post.title.toWordParts()
194 |
195 | val relatedReply = if (Math.random() > RuntimeVariables.Common.unrelatedAnswerChance) {
196 | markovChain.tryGeneratingReplyFromWords(wordsInTitle, platform = "Reddit")
197 | } else {
198 | null
199 | }
200 |
201 | val actualReply = if (relatedReply != null) {
202 | logger.info("Replying to post ${post.id} ('${post.title}') with related answer...")
203 | relatedReply
204 | } else {
205 | markovChain.generateRandomReply().also {
206 | logger.info("Default replied to post ${post.id} ('${post.title}')...")
207 | }
208 | }
209 |
210 | post.toReference(redditClient).safeReply(actualReply)
211 | commentCounter++
212 |
213 | delay(RuntimeVariables.Reddit.delayBetweenComments)
214 | }
215 | }
216 |
217 | for (comment in newComments) {
218 | if (commentCounter >= RuntimeVariables.Reddit.maxCommentsPerCheck) {
219 | logger.warn("Hit comment limit, not posting any more replies.")
220 | return@launch
221 | }
222 |
223 | if (comment.id in newInboxMessages.map { it.id }) {
224 | continue
225 | }
226 |
227 | if (CommonConstants.triggerKeyword.lowercase() in comment.body.lowercase()) {
228 | val wordsInComment = comment.body.toWordParts()
229 |
230 | val relatedReply = if (Math.random() > RuntimeVariables.Common.unrelatedAnswerChance) {
231 | markovChain.tryGeneratingReplyFromWords(wordsInComment, platform = "Reddit")
232 | } else {
233 | null
234 | }
235 |
236 | val actualReply = if (relatedReply != null) {
237 | logger.info("Replying to comment ${comment.id} ('${comment.body}') with related answer...")
238 | relatedReply
239 | } else {
240 | markovChain.generateRandomReply().also {
241 | logger.info("Default replying to comment ${comment.id} ('${comment.body}')...")
242 | }
243 | }
244 |
245 | comment.toReference(redditClient).safeReply(actualReply)
246 | commentCounter++
247 |
248 | delay(RuntimeVariables.Reddit.delayBetweenComments)
249 | }
250 | }
251 | } catch (e: Exception) {
252 | logger.error("Error while running timer loop:", e)
253 | }
254 | }
255 | }
256 |
257 | // Keep coroutine scope alive
258 | launch {
259 | while (isActive) {
260 | delay(1.hours)
261 | }
262 | }
263 | }
264 |
265 | private fun PublicContributionReference.safeReply(text: String) {
266 | if (RuntimeVariables.Reddit.actuallySendReplies) {
267 | try {
268 | reply(text.take(5000))
269 | logger.info("Replied with '${text.take(5000)}'.")
270 | } catch (e: Exception) {
271 | logger.error("Reply failed:", e)
272 | }
273 | } else {
274 | logger.info("[NOT ACTUALLY REPLYING] Would have replied with '$text'.")
275 | }
276 | }
--------------------------------------------------------------------------------