Merge pull request #63 from noneplugin/feat/uninfo

feat!: migrate to nonebot-plugin-uninfo

Author: MeetWq

nonebot_plugin_chatrecorder/__init__.py

@@ -1,7 +1,8 @@
 from nonebot import require
 from nonebot.plugin import PluginMetadata
 
-require("nonebot_plugin_session_orm")
+require("nonebot_plugin_orm")
+require("nonebot_plugin_uninfo")
 require("nonebot_plugin_localstore")
 
 from . import adapters as adapters

nonebot_plugin_chatrecorder/adapters/console.py

@@ -1,17 +1,24 @@
+import uuid
 from dataclasses import asdict
 from datetime import datetime, timezone
-from itertools import count
 from typing import Any, Optional
 
 from nonebot.adapters import Bot as BaseBot
 from nonebot.message import event_postprocessor
 from nonebot_plugin_orm import get_session
-from nonebot_plugin_session import Session, SessionLevel, extract_session
-from nonebot_plugin_session_orm import SessionModel, get_session_persist_id
+from nonebot_plugin_uninfo import (
+    Scene,
+    SceneType,
+    Session,
+    SupportAdapter,
+    SupportScope,
+    Uninfo,
+    User,
+)
+from nonebot_plugin_uninfo.orm import get_session_persist_id
 from typing_extensions import override
 
 from ..config import plugin_config
-from ..consts import SupportedAdapter, SupportedPlatform
 from ..message import (
     MessageDeserializer,
     MessageSerializer,
@@ -25,36 +32,21 @@
 try:
     from nonebot.adapters.console import Bot, Message, MessageEvent, MessageSegment
     from nonechat import ConsoleMessage, Emoji, Text
-    from sqlalchemy import select
-
-    adapter = SupportedAdapter.console
 
-    id = None
+    adapter = SupportAdapter.console
 
-    async def get_id() -> str:
-        global id
-        if not id:
-            statement = (
-                select(MessageRecord.message_id)
-                .where(SessionModel.bot_type == adapter)
-                .order_by(MessageRecord.message_id.desc())
-                .join(SessionModel, SessionModel.id == MessageRecord.session_persist_id)
-            )
-            async with get_session() as db_session:
-                message_id = await db_session.scalar(statement)
-            id = count(int(message_id) + 1) if message_id else count(0)
-        return str(next(id))
+    def get_id() -> str:
+        return uuid.uuid4().hex
 
     @event_postprocessor
-    async def record_recv_msg(bot: Bot, event: MessageEvent):
-        session = extract_session(bot, event)
+    async def record_recv_msg(event: MessageEvent, session: Uninfo):
         session_persist_id = await get_session_persist_id(session)
 
         record = MessageRecord(
             session_persist_id=session_persist_id,
             time=remove_timezone(event.time.astimezone(timezone.utc)),
             type=record_type(event),
-            message_id=await get_id(),
+            message_id=get_id(),
             message=serialize_message(adapter, event.get_message()),
             plain_text=event.get_plaintext(),
         )
@@ -78,13 +70,11 @@ async def record_send_msg(
                 return
 
             session = Session(
-                bot_id=bot.self_id,
-                bot_type=bot.type,
-                platform=SupportedPlatform.console,
-                level=SessionLevel.LEVEL1,
-                id1=data.get("user_id"),
-                id2=None,
-                id3=None,
+                self_id=bot.self_id,
+                adapter=adapter,
+                scope=SupportScope.console,
+                scene=Scene(id=data["user_id"], type=SceneType.PRIVATE),
+                user=User(id=bot.self_id),
             )
             session_persist_id = await get_session_persist_id(session)
 
@@ -105,7 +95,7 @@ async def record_send_msg(
                 session_persist_id=session_persist_id,
                 time=remove_timezone(datetime.now(timezone.utc)),
                 type="message_sent",
-                message_id=await get_id(),
+                message_id=get_id(),
                 message=serialize_message(adapter, message),
                 plain_text=message.extract_plain_text(),
             )

nonebot_plugin_chatrecorder/adapters/discord.py

@@ -3,12 +3,19 @@
 from nonebot.adapters import Bot as BaseBot
 from nonebot.message import event_postprocessor
 from nonebot_plugin_orm import get_session
-from nonebot_plugin_session import Session, SessionLevel, extract_session
-from nonebot_plugin_session_orm import get_session_persist_id
+from nonebot_plugin_uninfo import (
+    Scene,
+    SceneType,
+    Session,
+    SupportAdapter,
+    SupportScope,
+    Uninfo,
+    User,
+)
+from nonebot_plugin_uninfo.orm import get_session_persist_id
 from typing_extensions import override
 
 from ..config import plugin_config
-from ..consts import SupportedAdapter, SupportedPlatform
 from ..message import (
     MessageDeserializer,
     MessageSerializer,
@@ -23,11 +30,10 @@
     from nonebot.adapters.discord import Bot, Message, MessageEvent
     from nonebot.adapters.discord.api import UNSET, Channel, ChannelType, MessageGet
 
-    adapter = SupportedAdapter.discord
+    adapter = SupportAdapter.discord
 
     @event_postprocessor
-    async def record_recv_msg(bot: Bot, event: MessageEvent):
-        session = extract_session(bot, event)
+    async def record_recv_msg(event: MessageEvent, session: Uninfo):
         session_persist_id = await get_session_persist_id(session)
 
         record = MessageRecord(
@@ -71,30 +77,26 @@ async def record_send_msg(
                 return
 
             channel = await get_channel(bot, result.channel_id)
-
-            level = SessionLevel.LEVEL0
-            id1 = None
-            id2 = str(result.channel_id)
-            id3 = None
+            parent = None
             if channel.type in [ChannelType.DM]:
-                level = SessionLevel.LEVEL1
-                id1 = (
+                scene_type = SceneType.PRIVATE
+                scene_id = (
                     str(channel.recipients[0].id)
                     if channel.recipients != UNSET and channel.recipients
-                    else None
+                    else ""
                 )
             else:
-                level = SessionLevel.LEVEL3
-                id3 = str(channel.guild_id) if channel.guild_id != UNSET else None
+                scene_type = SceneType.CHANNEL_TEXT
+                scene_id = str(result.channel_id)
+                if channel.guild_id != UNSET:
+                    parent = Scene(id=str(channel.guild_id), type=SceneType.GUILD)
 
             session = Session(
-                bot_id=bot.self_id,
-                bot_type=bot.type,
-                platform=SupportedPlatform.discord,
-                level=level,
-                id1=id1,
-                id2=id2,
-                id3=id3,
+                self_id=bot.self_id,
+                adapter=adapter,
+                scope=SupportScope.discord,
+                scene=Scene(id=scene_id, type=scene_type, parent=parent),
+                user=User(id=bot.self_id),
             )
             session_persist_id = await get_session_persist_id(session)
 

nonebot_plugin_chatrecorder/adapters/dodo.py

@@ -4,12 +4,19 @@
 from nonebot.adapters import Bot as BaseBot
 from nonebot.message import event_postprocessor
 from nonebot_plugin_orm import get_session
-from nonebot_plugin_session import Session, SessionLevel, extract_session
-from nonebot_plugin_session_orm import get_session_persist_id
+from nonebot_plugin_uninfo import (
+    Scene,
+    SceneType,
+    Session,
+    SupportAdapter,
+    SupportScope,
+    Uninfo,
+    User,
+)
+from nonebot_plugin_uninfo.orm import get_session_persist_id
 from typing_extensions import override
 
 from ..config import plugin_config
-from ..consts import SupportedAdapter, SupportedPlatform
 from ..message import (
     MessageDeserializer,
     MessageSerializer,
@@ -24,11 +31,10 @@
     from nonebot.adapters.dodo import Bot, Message, MessageEvent
     from nonebot.adapters.dodo.models import MessageReturn
 
-    adapter = SupportedAdapter.dodo
+    adapter = SupportAdapter.dodo
 
     @event_postprocessor
-    async def record_recv_msg(bot: Bot, event: MessageEvent):
-        session = extract_session(bot, event)
+    async def record_recv_msg(event: MessageEvent, session: Uninfo):
         session_persist_id = await get_session_persist_id(session)
 
         record = MessageRecord(
@@ -58,29 +64,25 @@ async def record_send_msg(
             if e or not result or not isinstance(result, MessageReturn):
                 return
 
-            island_source_id = None
-            channel_id = None
             if api == "set_channel_message_send":
-                level = SessionLevel.LEVEL3
-                channel_id = data["channel_id"]
-                dodo_source_id = data.get("dodo_source_id")
+                scene_type = SceneType.CHANNEL_TEXT
+                scene_id = data["channel_id"]
+                parent = None
             elif api == "set_personal_message_send":
-                level = SessionLevel.LEVEL1
-                island_source_id = data["island_source_id"]
-                dodo_source_id = data["dodo_source_id"]
+                scene_type = SceneType.PRIVATE
+                scene_id = data["dodo_source_id"]
+                parent = Scene(id=data["island_source_id"], type=SceneType.GUILD)
             else:
                 return
 
             message = Message.from_message_body(data["message_body"])
 
             session = Session(
-                bot_id=bot.self_id,
-                bot_type=bot.type,
-                platform=SupportedPlatform.dodo,
-                level=level,
-                id1=dodo_source_id,
-                id2=channel_id,
-                id3=island_source_id,
+                self_id=bot.self_id,
+                adapter=adapter,
+                scope=SupportScope.dodo,
+                scene=Scene(id=scene_id, type=scene_type, parent=parent),
+                user=User(id=bot.self_id),
             )
             session_persist_id = await get_session_persist_id(session)
 

nonebot_plugin_chatrecorder/adapters/feishu.py

@@ -5,12 +5,19 @@
 from nonebot.adapters import Bot as BaseBot
 from nonebot.message import event_postprocessor
 from nonebot_plugin_orm import get_session
-from nonebot_plugin_session import Session, SessionLevel, extract_session
-from nonebot_plugin_session_orm import get_session_persist_id
+from nonebot_plugin_uninfo import (
+    Scene,
+    SceneType,
+    Session,
+    SupportAdapter,
+    SupportScope,
+    Uninfo,
+    User,
+)
+from nonebot_plugin_uninfo.orm import get_session_persist_id
 from typing_extensions import override
 
 from ..config import plugin_config
-from ..consts import SupportedAdapter, SupportedPlatform
 from ..message import (
     MessageDeserializer,
     MessageSerializer,
@@ -24,11 +31,10 @@
 try:
     from nonebot.adapters.feishu import Bot, Message, MessageEvent
 
-    adapter = SupportedAdapter.feishu
+    adapter = SupportAdapter.feishu
 
     @event_postprocessor
-    async def record_recv_msg(bot: Bot, event: MessageEvent):
-        session = extract_session(bot, event)
+    async def record_recv_msg(event: MessageEvent, session: Uninfo):
         session_persist_id = await get_session_persist_id(session)
 
         record = MessageRecord(
@@ -82,24 +88,17 @@ async def record_send_msg(
             resp = await get_chat_info(bot, chat_id)
             chat_mode = resp["data"]["chat_mode"]
 
-            level = SessionLevel.LEVEL0
-            id1 = None
-            id2 = None
             if chat_mode == "p2p":
-                level = SessionLevel.LEVEL1
-                id1 = resp["data"]["owner_id"]
+                scene_type = SceneType.PRIVATE
             elif chat_mode == "group":
-                level = SessionLevel.LEVEL2
-                id2 = chat_id
+                scene_type = SceneType.GROUP
 
             session = Session(
-                bot_id=bot.self_id,
-                bot_type=bot.type,
-                platform=SupportedPlatform.feishu,
-                level=level,
-                id1=id1,
-                id2=id2,
-                id3=None,
+                self_id=bot.self_id,
+                adapter=adapter,
+                scope=SupportScope.feishu,
+                scene=Scene(id=chat_id, type=scene_type),
+                user=User(id=bot.self_id),
             )
             session_persist_id = await get_session_persist_id(session)