<onebot>[feat]support event: GroupBanNoticeEvent; [feat]support msg_c…

…hain: Quote(Receive) At

README.markdown

@@ -58,9 +58,9 @@
 - [x] Image
 - [x] Audio
 - [ ] File
-- [ ] At
+- [x] At
 - [ ] MarketFace
-- [ ] Quote
+- [x] Quote (Receive Only)
 
 ## 事件
 
@@ -75,10 +75,10 @@
 - [ ] GroupAdmin
 - [x] GroupDecrease
 - [ ] GroupIncrease
-- [ ] GroupBan
+- [x] GroupBan
 - [ ] FriendAdd
 - [x] GroupRecall
-- [ ] FriendRecall
+- [x] FriendRecall
 - [ ] PokeNotify
 - [ ] LuckyKingNotify
 - [ ] HonorNotify

app.py

@@ -9,7 +9,8 @@
     GroupRecall,
     GroupMemberQuit,
     GroupInvite,
-    GroupMemberJoinRequest
+    GroupMemberJoinRequest,
+    GroupMuteMember
 )
 from lagrange.client.events.friend import (
     FriendMessage,
@@ -22,7 +23,8 @@
     GroupDecreaseEventHandler,
     GroupRecallEventHandler,
     GroupRequestEventHandler,
-    FriendRecallEventHandler
+    FriendRecallEventHandler,
+    GroupBanEventHandler
 )
 from onebot.utils.database import db
 from onebot.utils.datamodels import UserInformation
@@ -73,4 +75,5 @@ async def handle_kick(client: "Client", event: "ServerKick"):
 lag.subscribe(GroupInvite, GroupRequestEventHandler)
 lag.subscribe(GroupMemberJoinRequest, GroupRequestEventHandler)
 lag.subscribe(FriendRecall, FriendRecallEventHandler)
+lag.subscribe(GroupMuteMember, GroupBanEventHandler)
 lag.subscribe(ServerKick, handle_kick)

onebot/communications/api.py

@@ -4,6 +4,7 @@
 
 from lagrange.client.client import Client, BotFriend
 from lagrange.client.message.elems import Text
+from lagrange.client.message.types import Element
 from lagrange.pb.service.group import GetGrpMemberInfoRspBody
 
 from onebot.utils.message_segment import MessageSegment
@@ -33,7 +34,7 @@ async def send_group_msg(self, group_id: int, message: list | str, echo: str, us
             message = self.message_converter.parse_message(message, MessageSegment)
             message_ = await self.message_converter.convert_to_elements(message, group_id)
         elif isinstance(message, str):
-            message_ = [Text(message)]
+            message_: List[Element] = [Text(message)]
             message = message_
         try:
             seq = await self.client.send_grp_msg(msg_chain=message_, grp_id=group_id) # type: ignore
@@ -46,7 +47,7 @@ async def send_group_msg(self, group_id: int, message: list | str, echo: str, us
             uid = self.client.uid,
             seq = seq,
             grp_id = group_id,
-            msg_chain = [json.dumps(element.__dict__, ensure_ascii=False) for element in message]
+            msg_chain = [segment.__dict__ for segment in (await self.message_converter.convert_to_segments(message_, "grp", group_id=group_id))]
         )
         db.save(msg_content)
         return {"status": "ok", "retcode": 0, "data": {"message_id": message_id}, "echo": echo}
@@ -59,7 +60,7 @@ async def send_private_msg(self, user_id: int, message: list | str, echo: str, g
             message = self.message_converter.parse_message(message, MessageSegment)
             message_ = await self.message_converter.convert_to_elements(message, 0, str(uid))
         elif isinstance(message, str):
-            message_ = [Text(message)]
+            message_: List[Element] = [Text(message)]
         try:
             seq = await self.client.send_friend_msg(msg_chain=message_, uid=str(uid)) # type: ignore
         except AssertionError:
@@ -71,7 +72,7 @@ async def send_private_msg(self, user_id: int, message: list | str, echo: str, g
             uid = self.client.uid,
             seq = seq,
             grp_id = group_id,
-            msg_chain = [(json.dumps(element.__dict__, ensure_ascii=False) for element in message)]
+            msg_chain = [segment.__dict__ for segment in (await self.message_converter.convert_to_segments(message_, "grp", uid=str(uid)))]
         )
         db.save(msg_content)
         return {"status": "ok", "retcode": 0, "data": {"message_id": seq}, "echo": echo}
@@ -125,16 +126,19 @@ async def get_msg(self, message_id: int, echo: str) -> dict:
         if message_event is None:
             return {"status": "failed", "retcode": -1, "data": None, "echo": echo}
         data = {
-            "message_type": "private",
+            "message_type": "private" if message_event.grp_id == 0 else "group",
             "message_id": message_event.msg_id,
             "real_id": message_event.msg_id,
-            "sender": GroupMessageSender(
-                user_id = message_event.uin,
-                nickname = message_event.nickname
-            ).model_dump(),
-            "message": [json.loads(chain) for chain in message_event.msg_chain]
+            "sender": self.message_converter.convert_to_dict(
+                GroupMessageSender(
+                    user_id = message_event.uin,
+                    nickname = message_event.nickname
+                )
+            ),
+            "message": message_event.msg_chain,
+            "time": message_event.time
         }
-        return {"status": "failed", "retcode": 0, "data": data, "echo": echo}
+        return {"status": "ok", "retcode": 0, "data": data, "echo": echo}
 
     async def get_forward_msg(self, id: str, echo: str) -> dict:
         # Not Impl

onebot/event/NoticeEvent.py

@@ -22,4 +22,11 @@ class GroupRecallNoticeEvent(NoticeEvent):
 class FriendRecallNoticeEvent(NoticeEvent):
     notice_type: str = "friend_recall"
     user_id: int = 0
-    message_id: int = 0
+    message_id: int = 0
+
+class GroupBanNoticeEvent(NoticeEvent):
+    notice_type: str = "group_ban"
+    group_id: int = 0
+    operator_id: int = 0
+    user_id: int = 0
+    duration: int = 0

onebot/handlers.py

@@ -7,7 +7,8 @@
     GroupRecall,
     GroupMemberQuit,
     GroupInvite,
-    GroupMemberJoinRequest
+    GroupMemberJoinRequest,
+    GroupMuteMember
 )
 from lagrange.client.events.friend import (
     FriendMessage,
@@ -21,7 +22,8 @@
 from onebot.event.NoticeEvent import (
     GroupDecreaseNoticeEvent,
     GroupRecallNoticeEvent,
-    FriendRecallNoticeEvent
+    FriendRecallNoticeEvent,
+    GroupBanNoticeEvent
 )
 from onebot.event.RequestEvent import (
     GroupRequestEvent
@@ -56,11 +58,12 @@ async def GroupMessageEventHandler(client: Client, converter: MessageConverter,
         return
 
     logger.onebot.info(f"Received message ({message_id}/{event.seq}) from group ({event.grp_id}): {event.msg}")
-
+    msg_chain = event.msg_chain
     event_content = event.__dict__
+    event_content.pop("msg_chain")
     record_data = MessageEvent(
         msg_id=message_id,
-        msg_chain=list([json.dumps(element.__dict__, ensure_ascii=False, default=converter.bytes_serializer) for element in event_content.pop("msg_chain")]),
+        msg_chain=[segment.__dict__ for segment in (await converter.convert_to_segments(msg_chain, "grp", group_id=event.grp_id))],
         **(event_content)
     )
     db.save(record_data)
@@ -98,7 +101,7 @@ async def PrivateMessageEventHandler(client: Client, converter: MessageConverter
         seq=event.seq,
         uin=event.from_uin,
         msg=event.msg,
-        msg_chain=list([json.dumps(element.__dict__, ensure_ascii=False, default=converter.bytes_serializer) for element in event_content.pop("msg_chain")])
+        msg_chain=[segment.__dict__ for segment in (await converter.convert_to_segments(event.msg_chain, "friend", uid=event.from_uid))]
     )
     db.save(record_data)
     formatted_event = PrivateMessageEvent(
@@ -207,3 +210,32 @@ async def FriendRecallEventHandler(client: Client, converter: MessageConverter,
             ensure_ascii=False
         )
     )
+
+
+@init_handler
+async def GroupBanEventHandler(client: Client, converter: MessageConverter, event: GroupMuteMember):
+    operator_uid = event.operator_uid
+    target_uid = event.target_uid
+    operator_uin = get_info(operator_uid)
+    target_uin = get_info(target_uid)
+    if operator_uin is None:
+        return
+    if target_uid != "" and target_uin is None:
+        return
+    duration = event.duration
+    if target_uid == "":
+        target_uin = 0
+        duration = -1
+    formatted_event = GroupBanNoticeEvent(
+        self_id = client.uin,
+        group_id = event.grp_id,
+        operator_id = int(operator_uin),
+        user_id = int(target_uin), # type: ignore
+        duration = duration
+    )
+    await ws.websocket_connection.send(
+        json.dumps(
+            converter.convert_to_dict(formatted_event),
+            ensure_ascii=False
+        )
+    )

onebot/utils/datamodels.py

@@ -27,7 +27,7 @@ class MessageEvent(LagrangeModel):
     grp_name: str = ""
     nickname: str = ""
     msg: str = ""
-    msg_chain: List[str] = []
+    msg_chain: List[dict] = []
 
 class UserInformation(LagrangeModel):
     TABLE_NAME: str | None = "UserInformation"

onebot/utils/message_chain.py

@@ -1,4 +1,4 @@
-from typing import List, Literal, Type
+from typing import List, Literal, Type, Any
 from urllib.parse import urlparse
 
 from lagrange.client.message.elems import Text, Image, At, Quote, MarketFace, Audio
@@ -7,6 +7,8 @@
 
 from onebot.utils.message_segment import MessageSegment
 from onebot.utils.audio import mp3_to_silk
+from onebot.utils.database import db
+from onebot.utils.datamodels import MessageEvent
 
 import io
 import httpx
@@ -27,18 +29,16 @@ async def convert_to_segments(self, elements: List[Element], message_type: Liter
         segments: List[MessageSegment] = []
         for element in elements:
             if isinstance(element, At):
-                segments.append(MessageSegment.at(str(element.uin)))
+                segments.append(MessageSegment.at(element.uin))
             elif isinstance(element, Quote):
-                segments.append(MessageSegment.reply(int(str(element.seq))))
+                msg_data: MessageEvent | Any = db.where_one(MessageEvent(), "uin = ? AND seq = ?", element.uin, element.seq, default=None)
+                if msg_data is None:
+                    continue
+                segments.append(MessageSegment.reply(msg_data.msg_id))
             elif isinstance(element, (Image, MarketFace)):
-                segments.append(MessageSegment.image(str(element.url)))
+                segments.append(MessageSegment.image(element.url))
             elif isinstance(element, Audio):
-                # RIP: wyapx 呜呜呜呜
-                if message_type == "grp":
-                    url = await self.client._highway.get_audio_down_url(element, gid=group_id)
-                elif message_type == "friend":
-                    url = await self.client._highway.get_audio_down_url(element, uid=uid)
-                segments.append(MessageSegment.record(file=url))
+                segments.append(MessageSegment.record(element.url))
             elif isinstance(element, Text):
                 segments.append(MessageSegment.text(element.text))
             else:
@@ -56,8 +56,25 @@ async def convert_to_elements(self, segments: List[MessageSegment], group_id: in
                 elements.append(At(uin=int(int(segment.data["qq"])))) # type: ignore
                 # Not Support Yet
             elif segment.type == "reply":
-                elements.append(Quote(seq=int(segment.data["id"]))) # type: ignore
-                # Not Support Yet
+                # message_id = segment.data["id"]
+                # message_event: MessageEvent | Any = db.where_one(MessageEvent(), "msg_id = ?", message_id, default=None)
+                # if not message_event:
+                #     continue
+                # elements.append(Quote.build(
+                #     GroupMessage(
+                #         uid=message_event.uid,
+                #         seq=message_event.seq,
+                #         time=message_event.time,
+                #         rand=message_event.rand,
+                #         grp_id=message_event.grp_id,
+                #         uin=message_event.uin,
+                #         grp_name=message_event.grp_name,
+                #         nickname=message_event.nickname,
+
+                #     )
+                # ))
+                continue
+                # Not Support Yet 谁爱写谁写吧
             elif segment.type == "image":
                 image_content = segment.data["file"]
                 image_content = await self._process_image_content(image_content)