Feature/misskey v13

.github/workflows/gradle-publish.yml

@@ -36,6 +36,8 @@ jobs:
       env:
         multim_misskey_token: ${{secrets.multim_misskey_token}}
         multim_misskey_instance: ${{secrets.multim_misskey_instance}}
+        multim_misskeyv13_token: ${{secrets.multim_misskeyv13_token}}
+        multim_misskeyv13_instance: ${{secrets.multim_misskeyv13_instance}}
         USERNAME: ${{ github.actor }}
         TOKEN: ${{ secrets.GITHUB_TOKEN }}
 

.github/workflows/pr-test.yml

@@ -33,5 +33,7 @@ jobs:
         env:
           multim_misskey_token: ${{secrets.multim_misskey_token}}
           multim_misskey_instance: ${{secrets.multim_misskey_instance}}
+          multim_misskeyv13_token: ${{secrets.multim_misskeyv13_token}}
+          multim_misskeyv13_instance: ${{secrets.multim_misskeyv13_instance}}
           USERNAME: ${{ github.actor }}
           TOKEN: ${{ secrets.GITHUB_TOKEN }}

build.gradle.kts

@@ -86,11 +86,15 @@ subprojects {
             props.load(file("${project.rootProject.projectDir}/local.properties").inputStream())
             systemProperties("multim_misskey_token" to props["multim_misskey_token"])
             systemProperties("multim_misskey_instance" to props["multim_misskey_instance"])
+            systemProperties("multim_misskeyv13_token" to props["multim_misskeyv13_token"])
+            systemProperties("multim_misskeyv13_instance" to props["multim_misskeyv13_instance"])
 
         } catch (e: Exception) {
             println("local.properties not found")
             systemProperties("multim_misskey_token" to System.getenv("multim_misskey_token"))
             systemProperties("multim_misskey_instance" to System.getenv("multim_misskey_instance"))
+            systemProperties("multim_misskeyv13_token" to System.getenv("multim_misskeyv13_token"))
+            systemProperties("multim_misskeyv13_instance" to System.getenv("multim_misskeyv13_instance"))
         }
 
         useJUnitPlatform()

impl/misskeyv13/build.gradle.kts

@@ -0,0 +1,41 @@
+dependencies {
+    implementation(project(":core"))
+}
+
+sourceSets {
+    test {
+        kotlin {
+            compileClasspath += project(":core").sourceSets.test.get().output
+            runtimeClasspath += project(":core").sourceSets.test.get().output
+        }
+    }
+}
+
+kotlin {
+
+}
+
+//tasks{
+//    val sourcesJar by creating(Jar::class) {
+//        archiveClassifier.set("sources")
+//        from(sourceSets["main"].allSource)
+//    }
+//}
+//
+//afterEvaluate {
+//    publishing {
+//        publications {
+//
+//
+//            create<MavenPublication>("maven") {
+//                groupId = project.group.toString()
+//                artifactId = "multim-${project.name}"
+//                version = project.version.toString()
+//                from(components["kotlin"])
+//                artifact(tasks["sourcesJar"])
+//            }
+//
+//
+//        }
+//    }
+//}

impl/misskeyv13/src/main/kotlin/dev/usbharu/multim/misskey/v13/MisskeyV12Info.kt

@@ -0,0 +1,33 @@
+package dev.usbharu.multim.misskey.v13
+
+import dev.usbharu.multim.ServiceInfo
+import dev.usbharu.multim.misskey.v13.api.MisskeyApis
+import dev.usbharu.multim.misskey.v13.api.MisskeyMultiMApis
+import dev.usbharu.multim.misskey.v13.common.api.MisskeyAccountApi
+import dev.usbharu.multim.misskey.v13.common.api.MisskeyApiClient
+import dev.usbharu.multim.misskey.v13.common.api.MisskeyEmojiApi
+import dev.usbharu.multim.misskey.v13.common.api.MisskeyIApi
+import dev.usbharu.multim.misskey.v13.common.api.MisskeyStatusApi
+import dev.usbharu.multim.misskey.v13.common.api.MisskeyTimelineApi
+import dev.usbharu.multim.model.SingleTokenAuth
+
+object MisskeyV13Info : ServiceInfo(
+    Regex("misskey"),
+    Regex("^13\\.[\\d.]+"),
+    { auth, baseUrl, client -> MisskeyApiClient(auth as SingleTokenAuth, baseUrl, client) },
+
+    { apiClient -> MisskeyApis(apiClient as MisskeyApiClient) },
+    {
+        if (it is MisskeyApis) {
+            MisskeyMultiMApis(
+                MisskeyStatusApi(it),
+                MisskeyAccountApi(it),
+                MisskeyTimelineApi(it),
+                MisskeyEmojiApi(it),
+                MisskeyIApi(it)
+            )
+        } else {
+            TODO()
+        }
+    }
+)

impl/misskeyv13/src/main/kotlin/dev/usbharu/multim/misskey/v13/api/Ap.kt

@@ -0,0 +1,21 @@
+package dev.usbharu.multim.misskey.v13.api
+
+import com.github.michaelbull.result.mapError
+import dev.usbharu.multim.error.*
+import dev.usbharu.multim.misskey.v13.common.api.MisskeyApiClient
+import dev.usbharu.multim.misskey.v13.model.ApShowRequest
+import dev.usbharu.multim.misskey.v13.model.ApShowResponse
+import io.ktor.client.plugins.*
+
+class Ap(val client: MisskeyApiClient) {
+    suspend fun show(apShowRequest: ApShowRequest): MultiMResult<ApShowResponse> {
+        return client.post<ApShowRequest, ApShowResponse>(apShowRequest, "api/ap/show").mapError {
+            val multiMError: MultiMError = when (it) {
+                is HttpClientServerError -> MultiMHttpError(it.throwable as ServerResponseException)
+                is HttpClientClientError -> MultiMHttpError(it.throwable as ClientRequestException)
+                else -> MultiMError("Api Client Error", it.throwable, ErrorType.UNKNOWN)
+            }
+            multiMError
+        }
+    }
+}

impl/misskeyv13/src/main/kotlin/dev/usbharu/multim/misskey/v13/api/Drive.kt

@@ -0,0 +1,128 @@
+package dev.usbharu.multim.misskey.v13.api
+
+import dev.usbharu.multim.error.MultiMResult
+import dev.usbharu.multim.error.mapMultiMError
+import dev.usbharu.multim.misskey.v13.common.api.MisskeyApiClient
+import dev.usbharu.multim.misskey.v13.model.*
+import io.ktor.client.call.*
+import io.ktor.client.request.forms.*
+import io.ktor.http.*
+
+class Drive(val client: MisskeyApiClient) {
+    @Suppress("MemberNameEqualsClassName")
+    suspend fun drive(): MultiMResult<DriveResponse> {
+        return client.postEmpty<DriveResponse>("api/drive").mapMultiMError()
+    }
+
+    suspend fun files(filesRequest: DriveFilesRequest): MultiMResult<DriveFilesResponse> {
+        return client.post<DriveFilesRequest, DriveFilesResponse>(filesRequest, "api/drive/files")
+            .mapMultiMError()
+    }
+
+    suspend fun folders(foldersRequest: DriveFoldersRequest): MultiMResult<DriveFoldersResponse> {
+        return client.post<DriveFoldersRequest, DriveFoldersResponse>(
+            foldersRequest,
+            "api/drive/folders"
+        ).mapMultiMError()
+    }
+
+    inner class Files {
+        suspend fun attachedNotes(attachedNotesRequest: DriveFilesAttachedNotesRequest)
+                : MultiMResult<DriveFilesAttachedNotesResponse> {
+            return client.post<DriveFilesAttachedNotesRequest, DriveFilesAttachedNotesResponse>(
+                attachedNotesRequest,
+                "api/drive/files/attached-notes"
+            ).mapMultiMError()
+        }
+
+        suspend fun checkExistence(checkExistenceRequest: DriveFilesCheckExistenceRequest)
+                : MultiMResult<DriveFilesCheckExistenceResponse> {
+            return client.post<DriveFilesCheckExistenceRequest, DriveFilesCheckExistenceResponse>(
+                checkExistenceRequest,
+                "api/drive/files/check-existence"
+            ).mapMultiMError()
+        }
+
+        //TODO Result型対応
+        suspend fun create(createRequest: DriveFilesCreateRequest): DriveFilesCreateResponse {
+            return client.client.submitFormWithBinaryData(
+                client.baseUrl + "api/drive/files/create",
+                formData = formData {
+                    append("\"i\"", client.auth.token)
+                    append("\"file\"", createRequest.file, Headers.build {
+                        append(HttpHeaders.ContentDisposition, "filename=${createRequest.name}")
+                    })
+                }).body()
+//            return client.post(createRequest, "api/drive/files/create")
+        }
+
+        suspend fun delete(deleteRequest: DriveFilesDeleteRequest): MultiMResult<Unit> {
+            return client.postWithoutResponse(deleteRequest, "api/drive/files/delete")
+                .mapMultiMError()
+        }
+
+        suspend fun findByHash(findByHashRequest: DriveFilesFindByHashRequest)
+                : MultiMResult<DriveFilesFindByHashResponse> {
+            return client.post<DriveFilesFindByHashRequest, DriveFilesFindByHashResponse>(
+                findByHashRequest,
+                "api/drive/files/find-by-hash"
+            ).mapMultiMError()
+        }
+
+        suspend fun find(findRequest: DriveFilesFindRequest): MultiMResult<DriveFilesFindResponse> {
+            return client.post<DriveFilesFindRequest, DriveFilesFindResponse>(
+                findRequest,
+                "api/drive/files/find"
+            ).mapMultiMError()
+        }
+
+        suspend fun show(showRequest: DriveFilesShowRequestByUrl): MultiMResult<DriveFilesShowResponse> {
+            return client.post<DriveFilesShowRequestByUrl, DriveFilesShowResponse>(
+                showRequest,
+                "api/drive/files/show"
+            ).mapMultiMError()
+        }
+
+        suspend fun show(showRequest: DriveFilesShowRequestByFileId): MultiMResult<DriveFilesShowResponse> {
+            return client.post<DriveFilesShowRequestByFileId, DriveFilesShowResponse>(
+                showRequest,
+                "api/drive/files/show"
+            ).mapMultiMError()
+        }
+
+        suspend fun update(updateRequest: DriveFilesUpdateRequest): MultiMResult<DriveFilesUpdateResponse> {
+            return client.post<DriveFilesUpdateRequest, DriveFilesUpdateResponse>(
+                updateRequest,
+                "api/drive/files/update"
+            ).mapMultiMError()
+        }
+
+        suspend fun uploadFromUrl(uploadFromUrlRequest: DriveFilesUploadFromUrlRequest): MultiMResult<Unit> {
+            return client.postWithoutResponse(
+                uploadFromUrlRequest,
+                "api/drive/files/upload-from-url"
+            ).mapMultiMError()
+        }
+    }
+
+    inner class Folders {
+        suspend fun create(foldersCreateRequest: DriveFoldersCreateRequest): MultiMResult<DriveFoldersCreateResponse> {
+            return client.post<DriveFoldersCreateRequest, DriveFoldersCreateResponse>(
+                foldersCreateRequest,
+                "api/drive/folders/create"
+            ).mapMultiMError()
+        }
+
+        suspend fun delete(foldersDeleteRequest: DriveFoldersDeleteRequest): MultiMResult<Unit> {
+            return client.postWithoutResponse(foldersDeleteRequest, "api/drive/folders/delete")
+                .mapMultiMError()
+        }
+
+        suspend fun find(foldersFindRequest: DriveFoldersFindRequest): MultiMResult<DriveFoldersFindResponse> {
+            return client.post<DriveFoldersFindRequest, DriveFoldersFindResponse>(
+                foldersFindRequest,
+                "api/drive/folders/find"
+            ).mapMultiMError()
+        }
+    }
+}

impl/misskeyv13/src/main/kotlin/dev/usbharu/multim/misskey/v13/api/Following.kt

@@ -0,0 +1,58 @@
+package dev.usbharu.multim.misskey.v13.api
+
+import dev.usbharu.multim.error.MultiMResult
+import dev.usbharu.multim.error.mapMultiMError
+import dev.usbharu.multim.misskey.v13.common.api.MisskeyApiClient
+import dev.usbharu.multim.misskey.v13.model.*
+
+class Following(val client: MisskeyApiClient) {
+    suspend fun create(followingCreateRequest: FollowingCreateRequest): MultiMResult<FollowingCreateResponse> {
+        return client.post<FollowingCreateRequest, FollowingCreateResponse>(
+            followingCreateRequest,
+            "api/following/create"
+        ).mapMultiMError()
+    }
+
+    suspend fun delete(followingDeleteRequest: FollowingDeleteRequest): MultiMResult<FollowingDeleteResponse> {
+        return client.post<FollowingDeleteRequest, FollowingDeleteResponse>(
+            followingDeleteRequest,
+            "api/following/delete"
+        ).mapMultiMError()
+    }
+
+    suspend fun invalidate(followingInvalidateRequest: FollowingInvalidateRequest)
+    : MultiMResult<FollowingInvalidateResponse> {
+        return client.post<FollowingInvalidateRequest, FollowingInvalidateResponse>(
+            followingInvalidateRequest,
+            "api/following/invalidate"
+        ).mapMultiMError()
+    }
+
+    inner class Requests {
+        suspend fun accept(followingRequestsAcceptRequest: FollowingRequestsAcceptRequest): MultiMResult<Unit> {
+            return client.postWithoutResponse(
+                followingRequestsAcceptRequest,
+                "api/following/requests/list"
+            ).mapMultiMError()
+        }
+
+        suspend fun cancel(followingRequestsCancelRequest: FollowingRequestsCancelRequest): MultiMResult<Unit> {
+            return client.postWithoutResponse(
+                followingRequestsCancelRequest,
+                "api/following/requests/cancel"
+            ).mapMultiMError()
+        }
+
+        suspend fun list(): MultiMResult<FollowingRequestsListResponse> {
+            return client.postEmpty<FollowingRequestsListResponse>("api/following/requests/list")
+                .mapMultiMError()
+        }
+
+        suspend fun reject(followingRequestsRejectRequest: FollowingRequestsRejectRequest): MultiMResult<Unit> {
+            return client.postWithoutResponse(
+                followingRequestsRejectRequest,
+                "api/following/requests/reject"
+            ).mapMultiMError()
+        }
+    }
+}

impl/misskeyv13/src/main/kotlin/dev/usbharu/multim/misskey/v13/api/I.kt

@@ -0,0 +1,14 @@
+package dev.usbharu.multim.misskey.v13.api
+
+import dev.usbharu.multim.error.MultiMResult
+import dev.usbharu.multim.error.mapMultiMError
+import dev.usbharu.multim.misskey.v13.common.api.MisskeyApiClient
+import dev.usbharu.multim.misskey.v13.model.IIRequest
+import dev.usbharu.multim.misskey.v13.model.IIResponse
+
+@Suppress("MemberNameEqualsClassName")
+class I(val misskeyApiClient: MisskeyApiClient) {
+    suspend fun i(iiRequest: IIRequest = IIRequest()): MultiMResult<IIResponse> {
+        return misskeyApiClient.post<IIRequest, IIResponse>(iiRequest, "api/i").mapMultiMError()
+    }
+}

impl/misskeyv13/src/main/kotlin/dev/usbharu/multim/misskey/v13/api/Meta.kt

@@ -0,0 +1,15 @@
+package dev.usbharu.multim.misskey.v13.api
+
+import dev.usbharu.multim.error.MultiMResult
+import dev.usbharu.multim.error.mapMultiMError
+import dev.usbharu.multim.misskey.v13.common.api.MisskeyApiClient
+import dev.usbharu.multim.misskey.v13.model.MetaRequest
+import dev.usbharu.multim.misskey.v13.model.MetaResponse
+
+@Suppress("MemberNameEqualsClassName")
+class Meta(val client: MisskeyApiClient) {
+    suspend fun meta(metaRequest: MetaRequest): MultiMResult<MetaResponse> {
+        return client.post<MetaRequest, MetaResponse>(metaRequest, "api/meta")
+            .mapMultiMError()
+    }
+}

impl/misskeyv13/src/main/kotlin/dev/usbharu/multim/misskey/v13/api/Miauth.kt

@@ -0,0 +1,32 @@
+package dev.usbharu.multim.misskey.v13.api
+
+import com.github.michaelbull.result.map
+import dev.usbharu.multim.error.MultiMResult
+import dev.usbharu.multim.error.mapMultiMError
+import dev.usbharu.multim.misskey.v13.common.api.MisskeyApiClient
+import dev.usbharu.multim.misskey.v13.model.MiauthCheckRequest
+import dev.usbharu.multim.misskey.v13.model.MiauthCheckResponse
+import io.ktor.client.statement.*
+import java.util.*
+
+
+class Miauth(val client: MisskeyApiClient) {
+
+    suspend fun auth(): MultiMResult<String> {
+
+        val body = client.get(client.baseUrl + "/miauth/" + UUID.randomUUID() + "/") {
+            url {
+
+                parameters.append("name", "multim-test")
+                parameters.append("permission", "read:account,write:notes")
+            }
+        }.map { it.bodyAsText() }
+        return body.mapMultiMError()
+    }
+
+    suspend fun check(params: MiauthCheckRequest): MultiMResult<MiauthCheckResponse> {
+        return client.postEmpty<MiauthCheckResponse>("", "/api/miauth/${params.sessionId}/check")
+            .mapMultiMError()
+    }
+
+}

impl/misskeyv13/src/main/kotlin/dev/usbharu/multim/misskey/v13/api/MisskeyApis.kt

@@ -0,0 +1,15 @@
+package dev.usbharu.multim.misskey.v13.api
+
+import dev.usbharu.multim.api.PlatformApis
+import dev.usbharu.multim.misskey.v13.common.api.MisskeyApiClient
+
+class MisskeyApis(misskeyApiClient: MisskeyApiClient) : PlatformApis(misskeyApiClient) {
+    val notes = Notes(misskeyApiClient)
+    val ap = Ap(misskeyApiClient)
+    val miauth = Miauth(misskeyApiClient)
+    val timeline = Timeline(misskeyApiClient)
+    val following = Following(misskeyApiClient)
+    val users = Users(misskeyApiClient)
+    val meta = Meta(misskeyApiClient)
+    val i = I(misskeyApiClient)
+}