MisskeyNoteReactionViewer.is

/// @ 0.18.0
### {
  name: "ノートについたリアクション・リノートの詳細を閲覧するプラグイン"
  version: "0.3.0"
  author: "はとぽぷ(@hatopop_vr@misskey.io)"
  description: "ノートについたリアクション・リノートの詳細を閲覧"
  permissions: ["read:reactions"]
}

// ServerNameの取得
let SERVER_NAME = Mk:url().split('/')[2]

// 日時をフォーマットして取得する関数
@getCurrentDateTime() {
    return `{Date:year()}-{Date:month()}-{Date:day()} {Date:hour()}:{Date:minute()}:{Date:second()}.{Math:floor(Date:now()%1000/100)}`
}

// ログ出力関数を定義
@logInfo(message) {
    let dateTime = getCurrentDateTime()
    print(`{dateTime} - INFO - {message}`)
}

@logError(message) {
    let dateTime = getCurrentDateTime()
    print(`{dateTime} - ERROR - {message}`)
}

// リアクションから不要な文字を除去１ リアクションを取得
@removeChar(reaction) {
    return reaction.replace(`@.`, ``)
}

// リアクションから不要な文字を除去２ 名称を取得
@removeChar2(reaction) {
    return reaction.replace(`:`, ``)
}

// indexに基づいてソート
@sortByIndices(sortedIndices, targetList) {
    let sortedList = []
    each (let i sortedIndices) {
        sortedList.push(targetList[i])
    }
    sortedList
}

// ソート処理
@sortTargetByCount(targetList, countList) {
    let sortedIndices = []
    for (let i, countList.len) {
        sortedIndices.push(i)
    }

    sortedIndices.sort(@(a, b) {
        return countList[b] - countList[a]
    })

    let sortedTargetList = sortByIndices(sortedIndices, targetList)
    let sortedCountList = sortByIndices(sortedIndices, countList)

    let sortedObj = {}
    Obj:set(sortedObj, "sortedTargetList", sortedTargetList)
    Obj:set(sortedObj, "sortedCountList", sortedCountList)
    sortedObj
}

// APIからノートのリアクションを取得
@getNoteReactions(note_id, limit, requestMaxCount) {
    let resultList = []
    logInfo(`Fetching reactions for note ID {note_id} with limit {limit} and max count {requestMaxCount}`)
    var result = Mk:api(`notes/reactions` {noteId: note_id, limit: limit})

    if (result.len == 0) {
        logInfo(`No reactions found for note ID {note_id}`)
        return resultList
    }

    each (let res result){
        resultList.push(res)
    }

    var until_id = result[result.len - 1].id
    var count = 1

    loop {
        if count == requestMaxCount break

        var payload = {noteId: note_id, limit: limit, untilId: until_id}

        result = Mk:api(`notes/reactions` payload)
        if (result.len == 0) break

        each (let res result){
            resultList.push(res)
        }

        until_id = result[result.len - 1].id
        count = count + 1
    }

    logInfo(`Fetched {resultList.len} reactions for note ID {note_id}`)
    resultList
}

// APIからノートのリノートを取得
@getNoteRenotes(note_id, limit, requestMaxCount) {
    let resultList = []
    logInfo(`Fetching renotes for note ID {note_id} with limit {limit} and max count {requestMaxCount}`)
    var result = Mk:api(`notes/renotes` {noteId: note_id, limit: limit})

    if (result.len == 0) {
        logInfo(`No renotes found for note ID {note_id}`)
        return resultList
    }

    each (let res result){
        resultList.push(res)
    }

    var until_id = result[result.len - 1].id
    var count = 1

    loop {
        if count == requestMaxCount break

        var payload = {noteId: note_id, limit: limit, untilId: until_id}

        result = Mk:api(`notes/renotes` payload)
        if (result.len == 0) break

        each (let res result){
            resultList.push(res)
        }

        until_id = result[result.len - 1].id
        count = count + 1
    }

    logInfo(`Fetched {resultList.len} renotes for note ID {note_id}`)
    resultList
}

// リアクションを集計
@aggregateNoteReactions(reactions) {
    logInfo(`Aggregating reactions`)
    // リアクションの集計
    let reactionList = []
    let reactionCount = {}

    each (let reactionSet reactions) {
        var reaction = removeChar(reactionSet.type)
        var userHost = reactionSet.user.host
        var user = `@{reactionSet.user.username}`

        // リモートユーザー対応
        if (userHost == null) {
            user = `@{reactionSet.user.username}`
        } else {
            user = `@{reactionSet.user.username}@{userHost}`
        }

        // reactionのリストの追加
        if (!reactionList.incl(reaction)) {
            reactionList.push(reaction)
        }

        // reactionCountにreactionがなければ初期化
        if (Obj:has(reactionCount, reaction) == false) {
            Obj:set(reactionCount, reaction, { users: [] })
        }

        let reactionUsers = Obj:get(Obj:get(reactionCount, reaction), 'users')
        reactionUsers.push(user)
    }

    // countListに各リアクション数(ユーザー数)の追加
    let countList = []
    each (let reaction reactionList) {
        let reactionUsers = Obj:get(Obj:get(reactionCount, reaction), 'users')
        countList.push(reactionUsers.len)
    }

    logInfo(`Aggregated {reactionList.len} unique reactions`)
    let resultObj = {}
    Obj:set(resultObj, "reactionCount", reactionCount)
    Obj:set(resultObj, "reactionList", reactionList)
    Obj:set(resultObj, "countList", countList)
    resultObj
}

@sortHostCountsDescending(hostCounts) {
    let sortedHosts = Obj:keys(hostCounts)
    sortedHosts.sort(@(a, b) {
        return Obj:get(hostCounts, b) - Obj:get(hostCounts, a)
    })
    sortedHosts
}

@aggregateNoteReactionsByHost(reactions) {
    logInfo("Aggregating reactions by host")
    let reactionHostCount = {}

    each (let reactionSet reactions) {
        var userHost = reactionSet.user.host //  || "local"

        if (userHost == null) {
            userHost = `[{SERVER_NAME}](https://{SERVER_NAME})`
        } else {
            userHost = `[{reactionSet.user.host}](https://{reactionSet.user.host})`
        }

        // reactionHostCountにホストがなければ初期化
        if (Obj:has(reactionHostCount, userHost) == false) {
            Obj:set(reactionHostCount, userHost, 0)
        }

        let reactionCount = Obj:get(reactionHostCount, userHost)
        Obj:set(reactionHostCount, userHost, reactionCount + 1)
    }

    logInfo("Completed aggregating reactions by host")
    reactionHostCount
}

@aggregateNoteRenotesByHost(renotes) {
    logInfo("Aggregating renotes by host")
    let renoteHostCount = {}

    each (let renoteSet renotes) {
        var userHost = renoteSet.user.host

        if (userHost == null) {
            userHost = `[{SERVER_NAME}](https://{SERVER_NAME})`
        } else {
            userHost = `[{renoteSet.user.host}](https://{renoteSet.user.host})`
        }

        // renoteHostCountにホストがなければ初期化
        if (Obj:has(renoteHostCount, userHost) == false) {
            Obj:set(renoteHostCount, userHost, 0)
        }

        let renoteCount = Obj:get(renoteHostCount, userHost)
        Obj:set(renoteHostCount, userHost, renoteCount + 1)
    }

    logInfo("Completed aggregating renotes by host")
    renoteHostCount
}

// リノートを集計
@aggregateNoteRenotes(renotes) {
    logInfo("Aggregating renotes")
    // ユーザーとリノートを保存するためのオブジェクト
    let userRenoteCount = {}
    let userList = []

    each (let renoteSet renotes) {
        var renote = `:rn:`
        var userHost = renoteSet.user.host
        var user = `@{renoteSet.user.username}`

        // リモートユーザー対応
        if (userHost == null) {
            user = `@{renoteSet.user.username}`
        } else {
            user = `@{renoteSet.user.username}@{userHost}`
        }

        // userのリストの追加
        if (!userList.incl(user)) {
            userList.push(user)
        }

        // userRenoteCountにuserがなければ初期化
        if (Obj:has(userRenoteCount, user) == false) {
            Obj:set(userRenoteCount, user, { renotes: [] })
        }

        let userRenotes = Obj:get(Obj:get(userRenoteCount, user), 'renotes')

        // リアクションをユーザーに追加
        userRenotes.push(renote)

    }

    // countListに各リノート数の追加
    let countList = []
    each (let user userList){
        let userRenotes = Obj:get(Obj:get(userRenoteCount, user), 'renotes')
        countList.push(userRenotes.len)
    }

    logInfo(`Aggregated {userList.len} unique renote users`)
    let resultObj = {}
    Obj:set(resultObj, "userRenoteCount", userRenoteCount)
    Obj:set(resultObj, "userList", userList)
    Obj:set(resultObj, "countList", countList)
    resultObj
}

@misskeyNoteReationViewer(note) {
    logInfo(`==================================================`)
    logInfo(`Viewing reactions and renotes for note ID {note.id}`)
    // ダイアログのリアクション概要テキスト
    let dialogHeaderTextList = []
    // ダイアログのリアクション詳細テキスト
    let dialogReactionTextList = []
    // ダイアログのリノートテキストの作成
    let dialogRenoteTextList = []
    // ダイアログのホスト別リアクションテキスト
    let dialogHostReactionTextList = []
    // ダイアログのホスト別リノートテキスト
    let dialogHostRenoteTextList = []
    // リアクションの取得
    let reactions = getNoteReactions(note.id, 100, 100)
    var hostReactionCount = 0

    if (reactions.len > 0) {
        logInfo(`Found {reactions.len} reactions`)
        // リアクションの集計
        let reactionObj = aggregateNoteReactions(reactions)
        let reactionCount = Obj:get(reactionObj, "reactionCount")
        let reactionList = Obj:get(reactionObj, "reactionList")
        let countList = Obj:get(reactionObj, "countList")

        // ホスト別リアクションの集計
        let hostReactionObj = aggregateNoteReactionsByHost(reactions)
        // ホスト別リアクションの降順ソート
        let sortedHostReactions = sortHostCountsDescending(hostReactionObj)
        // ホスト別リアクションの件数の追加
        hostReactionCount = sortedHostReactions.len

        // ホスト別リアクションの集計結果の追加
        each (let host sortedHostReactions) {
            let count = Obj:get(hostReactionObj, host)
            if (count > 1) {
                dialogHostReactionTextList.push(`**{host}** {count}`)
            } else {
                dialogHostReactionTextList.push(`**{host}**`)
            }
        }

        // リアクション数順にソートしたオブジェクト
        let sortedReactionObj = sortTargetByCount(reactionList, countList)
        let sortedReactionList = Obj:get(sortedReactionObj, "sortedTargetList")

        each (let reaction sortedReactionList) {
            let reactionUsers = Obj:get(Obj:get(reactionCount, reaction), 'users')
            let dialogUserReactions = reactionUsers.join(" ")

            if (!(reaction).incl("@")) {
                dialogHeaderTextList.push(`{reaction}`)
            }
            dialogReactionTextList.push(`{reaction} {reactionUsers.len} {dialogUserReactions}`)
        }
    } else {
        logInfo(`No reactions found`)
    }

    // リノートの取得
    let renotes = getNoteRenotes(note.id, 100, 100)
    var userCount = 0
    var hostRenoteCount = 0

    if (renotes.len > 0) {
        logInfo(`Found {renotes.len} renotes`)
        // リノートの集計
        let renoteObj = aggregateNoteRenotes(renotes)
        let userRenoteCount = Obj:get(renoteObj, "userRenoteCount")
        let userList = Obj:get(renoteObj, "userList")
        let renoteCountList = Obj:get(renoteObj, "countList")
        userCount = userList.len

        // ホスト別リノートの集計
        let hostRenoteObj = aggregateNoteRenotesByHost(renotes)
        // ホスト別リノートの降順ソート
        let sortedHostRenotes = sortHostCountsDescending(hostRenoteObj)
        hostRenoteCount = sortedHostRenotes.len
        // ホスト別リノートの件数の追加
        each (let host sortedHostRenotes) {
            let count = Obj:get(hostRenoteObj, host)
            if (count > 1) {
                dialogHostRenoteTextList.push(`**{host}** {count}`)
            } else {
                dialogHostRenoteTextList.push(`**{host}**`)
            }
        }

        // リノート数順にソートしたオブジェクト
        let sortedRenoteObj = sortTargetByCount(userList, renoteCountList)
        let sortedRenoteUserList = Obj:get(sortedRenoteObj, "sortedTargetList")

        // renoteのリストの追加
        each (let renoteUser sortedRenoteUserList) {
            let userRenotes = Obj:get(Obj:get(userRenoteCount, renoteUser), 'renotes')
            let renoteCount = userRenotes.len
            if (renoteCount > 1) {
                dialogRenoteTextList.push(`{renoteUser} {renoteCount}`)
            } else {
                dialogRenoteTextList.push(`{renoteUser}`)
            }
        }
    } else {
        logInfo(`No renotes found`)
    }

    // 最終的なダイアログテキスト
    var dialogHeaderText = dialogHeaderTextList.join(" ")
    var dialogReactionText = dialogReactionTextList.join(Str:lf)
    var dialogRenoteText = dialogRenoteTextList.join(" ")
    var dialogHostReactionText = dialogHostReactionTextList.join(" ")
    var dialogHostRenoteText = dialogHostRenoteTextList.join(" ")
    let dialogTextMergedList = []

    if (reactions.len > 0) {
        // reactionのサマリの追加
        dialogTextMergedList.push(`**リアクション抜粋(ローカル)**`)
        dialogTextMergedList.push(dialogHeaderText)
        dialogTextMergedList.push("")
    }

    if (renotes.len > 0) {
        // renoteの詳細の追加
        dialogTextMergedList.push(`**リノート詳細: {userCount}({renotes.len})**`)
        dialogTextMergedList.push(dialogRenoteText)
        dialogTextMergedList.push("")
    }

    if (reactions.len > 0) {
        // reactionの詳細の追加
        dialogTextMergedList.push(`**リアクション詳細: {reactions.len}**`)
        dialogTextMergedList.push(dialogReactionText)
        dialogTextMergedList.push("")
    }

    if (dialogHostRenoteTextList.len > 0) {
        // ホスト別リノートの集計の追加
        dialogTextMergedList.push(`**ホスト別リノート集計: {hostRenoteCount}({renotes.len})**`)
        dialogTextMergedList.push(dialogHostRenoteText)
        dialogTextMergedList.push("")
    }

    if (dialogHostReactionTextList.len > 0) {
        // ホスト別リアクションの集計の追加
        dialogTextMergedList.push(`**ホスト別リアクション集計: {hostReactionCount}({reactions.len})**`)
        dialogTextMergedList.push(dialogHostReactionText)
        dialogTextMergedList.push("")
    }

    if (dialogTextMergedList.len == 0) {
        dialogTextMergedList.push(`**リアクション・リノートがありません**`)
    }

    var dialogTextMerged = dialogTextMergedList.join(Str:lf)

    logInfo(`Displaying dialog for note ID {note.id}`)
    Mk:dialog(`取得結果` dialogTextMerged)
    logInfo(`Completed viewing reactions and renotes for note ID {note.id}`)
    logInfo(`==================================================`)
}


// リアクションの詳細を取得するボタンの登録
Plugin:register_note_action(`リアクション詳細` @(note) {misskeyNoteReationViewer(note)})