wip: Filter out non-labeled posts

Currently only works on my last 100 likes

app/build.gradle.kts

···
     implementation(libs.ktor.client.cio)
     implementation(libs.ktor.client.content.negotiation)
     implementation(libs.ktor.client.logging)
+    implementation(libs.ktor.client.auth)
     implementation(libs.ktor.server.core)
     implementation(libs.ktor.server.netty)
     implementation(libs.ktor.server.content.negotiation)

app/src/main/kotlin/Application.kt

···
         pdsUrl = buildUrl {
             protocol = URLProtocol.HTTPS
             host = ownerPds
-        }
+        },
     )
 
     // Make sure the feed generator record exists and points to the current

app/src/main/kotlin/BskyApi.kt

···
 import io.ktor.client.call.*
 import io.ktor.client.engine.cio.*
 import io.ktor.client.plugins.*
+import io.ktor.client.plugins.auth.*
+import io.ktor.client.plugins.auth.providers.*
 import io.ktor.client.plugins.contentnegotiation.*
 import io.ktor.client.plugins.logging.*
 import io.ktor.client.request.*
···
 import kotlinx.serialization.json.Json
 
 class BskyApi(
-    private var pdsUrl: Url = Url("https://bsky.social"),
+    private val pdsUrl: Url = Url("https://bsky.social"),
+
+    private val bearerTokens: MutableList<BearerTokens> = mutableListOf(),
 
     private val httpClient: HttpClient = HttpClient(CIO) {
         install(ContentNegotiation) {
···
 
         install(Logging)
 
+        install(Auth) {
+            bearer {
+                loadTokens {
+                    bearerTokens.lastOrNull()
+                }
+
+                refreshTokens {
+                    val currentRefreshToken = bearerTokens.lastOrNull()?.refreshToken ?: return@refreshTokens null
+
+                    @Serializable
+                    data class Response(val accessJwt: String, val refreshJwt: String)
+
+                    val refreshSessionResponse = client.post("com.atproto.server.refreshSession") {
+                        header("Authorization", "Bearer $currentRefreshToken")
+                        markAsRefreshTokenRequest()
+                    }
+
+                    when (refreshSessionResponse.status) {
+                        HttpStatusCode.OK -> {
+                            val refreshSessionTokens = refreshSessionResponse.body<Response>()
+                            val newBearerTokens =
+                                BearerTokens(refreshSessionTokens.accessJwt, refreshSessionTokens.refreshJwt)
+
+                            bearerTokens.addLast(newBearerTokens)
+
+                            return@refreshTokens newBearerTokens
+                        }
+
+                        HttpStatusCode.BadRequest,
+                        HttpStatusCode.Unauthorized -> return@refreshTokens null
+
+                        else -> return@refreshTokens null
+                    }
+                }
+            }
+        }
+
         defaultRequest {
             url {
                 protocol = pdsUrl.protocol
···
         }
     },
 ) {
-
-
-    data class AuthTokens(
-        val accessJwt: String,
-        val refreshJwt: String,
-        val did: String,
-    )
-
-    private var authTokens: AuthTokens? = null
-
     @Serializable
     data class ErrorResponse(
         val error: String,
···
         when (response.status) {
             HttpStatusCode.OK -> {
                 val tokens: Response = response.body()
-                this.authTokens = AuthTokens(tokens.accessJwt, tokens.refreshJwt, tokens.did)
+                bearerTokens.addLast(BearerTokens(tokens.accessJwt, tokens.refreshJwt))
             }
 
             HttpStatusCode.BadRequest,
···
         @Serializable
         data class Request(
             val repo: String,
+            val collection: String,
             val rkey: String,
             val record: Generator,
-            val collection: String = "app.bsky.feed.generator",
         )
 
         val response = httpClient.post("com.atproto.repo.putRecord") {
             contentType(ContentType.Application.Json)
-            setBody(Request(repo, rkey, record))
+            setBody(Request(repo, "app.bsky.feed.generator", rkey, record))
         }
 
         when (response.status) {
···
             else -> throw RuntimeException("Unexpected response received: ${response.bodyAsText()}")
         }
     }
-}
+}

app/src/main/kotlin/DarkFeedApi.kt

···
 package gay.averyrivers
 
 import gay.averyrivers.lexicon.app.bsky.feed.FeedSkeleton
+import gay.averyrivers.lexicon.app.bsky.feed.defs.PostView
 import gay.averyrivers.lexicon.app.bsky.feed.defs.SkeletonFeedPost
 import io.ktor.serialization.kotlinx.json.*
 import io.ktor.server.application.*
···
         )
     }
 
-    // SOOOOO
-    // I NEED TO CHECK THE SELF LABEL (at://did:plc:vwivwqztbf6pmkgss3nv2scy/app.bsky.feed.post/3la5sxh4ica2r)
-    // AND THE MODERATION.BSKY.APP LABEL (at://did:plc:ujrpupcjf22a4riwjbupdv42/app.bsky.feed.post/3la5qntezsu2v)
-
     private suspend fun handleGetFeedSkeleton(call: RoutingCall) {
         // TODO: Get requestor's DID from Authorization header.
         call.respond(buildFeedSkeleton("did:plc:zhxv5pxpmojhnvaqy4mwailv"))
     }
 
     private suspend fun buildFeedSkeleton(requestor: String): FeedSkeleton {
+        val actorLikes = bskyApi.getLikesByActor(requestor)
+            .first
+            .map { likeRef -> likeRef.value.subject.uri }
+
+        val labeledPosts = actorLikes
+            .chunked(25)
+            .map { chunkedActorLikes ->
+                bskyApi.getPostLabels(chunkedActorLikes)
+                    .filter { post ->
+                        post.labels?.any { label -> listOf("porn", "sexual").contains(label.value) } ?: false
+                    }
+            }
+            .flatten()
+
+
         return FeedSkeleton(
-            feed = bskyApi.getLikesByActor(requestor)
-                .first
-                .map { likeRef -> SkeletonFeedPost(post = likeRef.value.subject.uri) }
+            feed = labeledPosts.map { post -> SkeletonFeedPost(post = post.uri) }
         )
     }
-}
+}

app/src/main/kotlin/lexicon/app/bsky/feed/defs/PostView.kt

···
 data class PostView(
     val uri: String,
     val cid: String,
-    val labels: List<Label>,
-)
+    val labels: List<Label>?,
+)

app/src/main/kotlin/lexicon/com/atproto/label/defs/Label.kt

···
 package gay.averyrivers.lexicon.com.atproto.label.defs
 
+import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 
 @Serializable
···
     val src: String,
     val uri: String,
     val cid: String?,
+    @SerialName("val")
     val value: String,
     val neg: Boolean?,
     val cts: String,
     val exp: String?,
-)
+)

app/src/main/resources/logback.xml

···
         <appender-ref ref="STDOUT"/>
     </root>
     <logger name="io.netty" level="INFO"/>
-    <logger name="io.ktor" level="TRACE"/>
+    <logger name="io.ktor.client" level="INFO"/>
+    <logger name="io.ktor.server" level="INFO"/>
 </configuration>

gradle/libs.versions.toml

···
 ktor-client-cio = { group = "io.ktor", name = "ktor-client-cio", version.ref = "ktor" }
 ktor-client-content-negotiation = { group = "io.ktor", name = "ktor-client-content-negotiation", version.ref = "ktor" }
 ktor-client-logging = { group = "io.ktor", name = "ktor-client-logging", version.ref = "ktor" }
+ktor-client-auth = { group = "io.ktor", name = "ktor-client-auth", version.ref = "ktor" }
 ktor-server-core = { group = "io.ktor", name = "ktor-server-core", version.ref = "ktor" }
 ktor-server-netty = { group = "io.ktor", name = "ktor-server-netty", version.ref = "ktor" }
 ktor-server-content-negotiation = { group = "io.ktor", name = "ktor-server-content-negotiation", version.ref = "ktor" }