euler-onebot 0.0.2__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- euler_onebot-0.0.2.dist-info/METADATA +158 -0
- euler_onebot-0.0.2.dist-info/RECORD +19 -0
- euler_onebot-0.0.2.dist-info/WHEEL +5 -0
- euler_onebot-0.0.2.dist-info/licenses/LICENSE +674 -0
- euler_onebot-0.0.2.dist-info/top_level.txt +1 -0
- euleronebot/config.py +79 -0
- euleronebot/hyperogger.py +171 -0
- euleronebot/onebot/__init__.py +80 -0
- euleronebot/onebot/api.py +291 -0
- euleronebot/onebot/api_data.py +277 -0
- euleronebot/onebot/connector.py +117 -0
- euleronebot/onebot/events.py +215 -0
- euleronebot/onebot/models.py +11 -0
- euleronebot/onebot/segments.py +159 -0
- euleronebot/protocol.py +528 -0
- euleronebot/utils/__init__.py +28 -0
- euleronebot/utils/infomgr.py +105 -0
- euleronebot/utils/transformer.py +224 -0
- euleronebot/versions.py +2 -0
|
@@ -0,0 +1,159 @@
|
|
|
1
|
+
from typing import Literal, TypeVar, Generic, Annotated, Union
|
|
2
|
+
|
|
3
|
+
from pydantic import BaseModel, Field
|
|
4
|
+
|
|
5
|
+
__all__ = [
|
|
6
|
+
"BaseSegment",
|
|
7
|
+
"Text",
|
|
8
|
+
"At",
|
|
9
|
+
"Reply",
|
|
10
|
+
"Face",
|
|
11
|
+
"Poke",
|
|
12
|
+
"MarketFace",
|
|
13
|
+
"Node",
|
|
14
|
+
"Forward",
|
|
15
|
+
"Image",
|
|
16
|
+
"Record",
|
|
17
|
+
"Video",
|
|
18
|
+
"SegmentUnion"
|
|
19
|
+
]
|
|
20
|
+
|
|
21
|
+
SegmentType = TypeVar("SegmentType")
|
|
22
|
+
|
|
23
|
+
|
|
24
|
+
class BaseSegmentData(BaseModel):
|
|
25
|
+
...
|
|
26
|
+
|
|
27
|
+
|
|
28
|
+
class BaseSegment(BaseModel, Generic[SegmentType]):
|
|
29
|
+
type: Literal["text", "at", "reply", "face", "poke", "mface", "node", "forward", "image", "record", "video"]
|
|
30
|
+
data: SegmentType
|
|
31
|
+
|
|
32
|
+
|
|
33
|
+
class TextData(BaseSegmentData):
|
|
34
|
+
text: str
|
|
35
|
+
|
|
36
|
+
|
|
37
|
+
class Text(BaseSegment[TextData]):
|
|
38
|
+
type: Literal["text"] = "text"
|
|
39
|
+
data: TextData
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
class AtData(BaseSegmentData):
|
|
43
|
+
qq: str
|
|
44
|
+
|
|
45
|
+
|
|
46
|
+
class At(BaseSegment[AtData]):
|
|
47
|
+
type: Literal["at"] = "at"
|
|
48
|
+
data: AtData
|
|
49
|
+
|
|
50
|
+
|
|
51
|
+
class ReplyData(BaseSegmentData):
|
|
52
|
+
id: str
|
|
53
|
+
|
|
54
|
+
|
|
55
|
+
class Reply(BaseSegment[ReplyData]):
|
|
56
|
+
type: Literal["reply"] = "reply"
|
|
57
|
+
data: ReplyData
|
|
58
|
+
|
|
59
|
+
|
|
60
|
+
class FaceData(BaseSegmentData):
|
|
61
|
+
id: str
|
|
62
|
+
|
|
63
|
+
|
|
64
|
+
class Face(BaseSegment[FaceData]):
|
|
65
|
+
type: Literal["face"] = "face"
|
|
66
|
+
data: FaceData
|
|
67
|
+
|
|
68
|
+
|
|
69
|
+
class PokeData(BaseSegmentData):
|
|
70
|
+
id: str
|
|
71
|
+
type: str
|
|
72
|
+
|
|
73
|
+
|
|
74
|
+
class Poke(BaseSegment[PokeData]):
|
|
75
|
+
type: Literal["poke"] = "poke"
|
|
76
|
+
data: PokeData
|
|
77
|
+
|
|
78
|
+
|
|
79
|
+
class MarketFaceData(BaseSegmentData):
|
|
80
|
+
face_id: str
|
|
81
|
+
tab_id: str
|
|
82
|
+
name: str
|
|
83
|
+
|
|
84
|
+
|
|
85
|
+
class MarketFace(BaseSegment[MarketFaceData]):
|
|
86
|
+
type: Literal["mface"] = "mface"
|
|
87
|
+
data: MarketFaceData
|
|
88
|
+
|
|
89
|
+
|
|
90
|
+
class NodeData(BaseSegmentData):
|
|
91
|
+
user_id: str
|
|
92
|
+
nickname: str
|
|
93
|
+
content: list[BaseSegment]
|
|
94
|
+
|
|
95
|
+
|
|
96
|
+
class Node(BaseSegment[NodeData]):
|
|
97
|
+
type: Literal["node"] = "node"
|
|
98
|
+
data: NodeData
|
|
99
|
+
|
|
100
|
+
|
|
101
|
+
class ForwardData(BaseSegmentData):
|
|
102
|
+
id: str = ""
|
|
103
|
+
content: list[Node] = []
|
|
104
|
+
|
|
105
|
+
|
|
106
|
+
class Forward(BaseSegment[ForwardData]):
|
|
107
|
+
type: Literal["forward"] = "forward"
|
|
108
|
+
data: ForwardData
|
|
109
|
+
|
|
110
|
+
|
|
111
|
+
class MediaBaseData(BaseSegmentData):
|
|
112
|
+
file: str
|
|
113
|
+
url: str = ""
|
|
114
|
+
|
|
115
|
+
|
|
116
|
+
class ImageData(MediaBaseData):
|
|
117
|
+
summary: str
|
|
118
|
+
is_emoji: bool = False
|
|
119
|
+
|
|
120
|
+
|
|
121
|
+
class Image(BaseSegment[ImageData]):
|
|
122
|
+
type: Literal["image"] = "image"
|
|
123
|
+
data: ImageData
|
|
124
|
+
|
|
125
|
+
|
|
126
|
+
class RecordData(MediaBaseData):
|
|
127
|
+
...
|
|
128
|
+
|
|
129
|
+
|
|
130
|
+
class Record(BaseSegment[RecordData]):
|
|
131
|
+
type: Literal["record"] = "record"
|
|
132
|
+
data: RecordData
|
|
133
|
+
|
|
134
|
+
|
|
135
|
+
class VideoData(MediaBaseData):
|
|
136
|
+
...
|
|
137
|
+
|
|
138
|
+
|
|
139
|
+
class Video(BaseSegment[VideoData]):
|
|
140
|
+
type: Literal["video"] = "video"
|
|
141
|
+
data: VideoData
|
|
142
|
+
|
|
143
|
+
|
|
144
|
+
SegmentUnion = Annotated[
|
|
145
|
+
Union[
|
|
146
|
+
Text,
|
|
147
|
+
At,
|
|
148
|
+
Reply,
|
|
149
|
+
Face,
|
|
150
|
+
Poke,
|
|
151
|
+
MarketFace,
|
|
152
|
+
Node,
|
|
153
|
+
Forward,
|
|
154
|
+
Image,
|
|
155
|
+
Record,
|
|
156
|
+
Video,
|
|
157
|
+
],
|
|
158
|
+
Field(discriminator="type")
|
|
159
|
+
]
|
euleronebot/protocol.py
ADDED
|
@@ -0,0 +1,528 @@
|
|
|
1
|
+
import asyncio
|
|
2
|
+
import time
|
|
3
|
+
import traceback
|
|
4
|
+
from typing import NoReturn
|
|
5
|
+
|
|
6
|
+
from lagrange import Lagrange
|
|
7
|
+
from lagrange.client.client import Client
|
|
8
|
+
from lagrange.client.events.friend import FriendMessage, FriendRecall
|
|
9
|
+
from lagrange.client.events.group import (
|
|
10
|
+
GroupMessage,
|
|
11
|
+
GroupRecall,
|
|
12
|
+
GroupMuteMember,
|
|
13
|
+
GroupMemberJoined,
|
|
14
|
+
GroupMemberJoinedByInvite,
|
|
15
|
+
GroupMemberQuit, GroupNudge, GroupReaction
|
|
16
|
+
)
|
|
17
|
+
|
|
18
|
+
from .config import load_config
|
|
19
|
+
from .onebot.api_data import *
|
|
20
|
+
from .onebot.models import TargetInfo
|
|
21
|
+
from .utils.infomgr import MsgInfo, info_mgr
|
|
22
|
+
from .utils.transformer import to_onebot_msg, to_lagrange_msg
|
|
23
|
+
from .onebot import events as onebot_events
|
|
24
|
+
from .onebot import Adapter as OneBotAdapter
|
|
25
|
+
from .onebot.api import *
|
|
26
|
+
from .hyperogger import Logger
|
|
27
|
+
|
|
28
|
+
appconfig = load_config("./appconfig.json")
|
|
29
|
+
logger = Logger.fetch("euler").name_custom("euler.protocol")
|
|
30
|
+
|
|
31
|
+
|
|
32
|
+
class LagrangeProtocol:
|
|
33
|
+
def __init__(self, onebot_adapter: OneBotAdapter):
|
|
34
|
+
self.adapter = onebot_adapter
|
|
35
|
+
self.lag = Lagrange(
|
|
36
|
+
appconfig.login.uin,
|
|
37
|
+
"linux",
|
|
38
|
+
(appconfig.login.signer_url + "/api/sign/sec-sign") \
|
|
39
|
+
.replace("https://", f"https://{appconfig.login.signer_token}@") \
|
|
40
|
+
.replace("http://", f"http://{appconfig.login.signer_token}@"),
|
|
41
|
+
)
|
|
42
|
+
|
|
43
|
+
self.lag.log.set_level("DEBUG")
|
|
44
|
+
|
|
45
|
+
async def run(self) -> None:
|
|
46
|
+
self.lag.subscribe(GroupMessage, self.grp_msg_handler)
|
|
47
|
+
self.lag.subscribe(FriendMessage, self.pri_msg_handler)
|
|
48
|
+
self.lag.subscribe(GroupRecall, self.grp_recall_handler)
|
|
49
|
+
self.lag.subscribe(FriendRecall, self.pri_recall_handler)
|
|
50
|
+
self.lag.subscribe(GroupMuteMember, self.grp_mute_handler)
|
|
51
|
+
self.lag.subscribe(GroupMemberJoined, self.grp_join_handler)
|
|
52
|
+
self.lag.subscribe(GroupMemberJoinedByInvite, self.grp_invite_join_handler)
|
|
53
|
+
self.lag.subscribe(GroupNudge, self.poke_handler)
|
|
54
|
+
self.lag.subscribe(GroupReaction, self.reaction_handler)
|
|
55
|
+
|
|
56
|
+
try:
|
|
57
|
+
await self.adapter.setup()
|
|
58
|
+
asyncio.create_task(self.adapter.cycle())
|
|
59
|
+
asyncio.create_task(self.api_service())
|
|
60
|
+
asyncio.create_task(self.heartbeat())
|
|
61
|
+
await self.lag.run()
|
|
62
|
+
except KeyboardInterrupt:
|
|
63
|
+
self.lag.client._task_clear()
|
|
64
|
+
logger.info("Program exited by user")
|
|
65
|
+
else:
|
|
66
|
+
logger.info("Program exited normally")
|
|
67
|
+
|
|
68
|
+
async def heartbeat(self) -> NoReturn:
|
|
69
|
+
while True:
|
|
70
|
+
await asyncio.sleep(appconfig.heartbeat.interval / 1000)
|
|
71
|
+
try:
|
|
72
|
+
await self.adapter.trigger(
|
|
73
|
+
onebot_events.HeartbeatEvent(
|
|
74
|
+
interval=appconfig.heartbeat.interval,
|
|
75
|
+
self_id=self.lag.client.uin,
|
|
76
|
+
status=onebot_events.BotStatus(good=True, online=True),
|
|
77
|
+
time=round(time.time())
|
|
78
|
+
)
|
|
79
|
+
)
|
|
80
|
+
except:
|
|
81
|
+
pass
|
|
82
|
+
|
|
83
|
+
async def api_service(self) -> NoReturn:
|
|
84
|
+
while True:
|
|
85
|
+
call = await self.adapter.api_calls.get()
|
|
86
|
+
try:
|
|
87
|
+
if isinstance(call, SendMessage): # Do it ahead
|
|
88
|
+
if call.params.group_id:
|
|
89
|
+
call = SendGroupMessage(
|
|
90
|
+
params=SendGroupMsgData(
|
|
91
|
+
group_id=call.params.group_id,
|
|
92
|
+
message=call.params.message
|
|
93
|
+
),
|
|
94
|
+
echo=call.echo
|
|
95
|
+
)
|
|
96
|
+
else:
|
|
97
|
+
call = SendPrivateMessage(
|
|
98
|
+
params=SendPrivateMsgData(
|
|
99
|
+
user_id=call.params.user_id,
|
|
100
|
+
message=call.params.message
|
|
101
|
+
),
|
|
102
|
+
echo=call.echo
|
|
103
|
+
)
|
|
104
|
+
|
|
105
|
+
if isinstance(call, SendPrivateMessage):
|
|
106
|
+
new_msg = await to_lagrange_msg(
|
|
107
|
+
msg=call.params.message,
|
|
108
|
+
lgrc=self.lag.client,
|
|
109
|
+
target=(TargetInfo(target="user", id=call.params.user_id))
|
|
110
|
+
)
|
|
111
|
+
seq = await self.lag.client.send_friend_msg(
|
|
112
|
+
uid=info_mgr.uid_mgr.from_uin(call.params.user_id),
|
|
113
|
+
msg_chain=new_msg
|
|
114
|
+
)
|
|
115
|
+
text = ""
|
|
116
|
+
for i in new_msg:
|
|
117
|
+
text += i.display
|
|
118
|
+
msgid = info_mgr.msgid_mgr.add(
|
|
119
|
+
MsgInfo(
|
|
120
|
+
raw_msg=new_msg,
|
|
121
|
+
scene_type="user",
|
|
122
|
+
scene_id=call.params.user_id,
|
|
123
|
+
seq=seq,
|
|
124
|
+
timestamp=round(time.time()),
|
|
125
|
+
uid=self.lag.client.uid,
|
|
126
|
+
uin=self.lag.client.uin,
|
|
127
|
+
text=text
|
|
128
|
+
)
|
|
129
|
+
)
|
|
130
|
+
rsp = SendPrivateMessageResponse(
|
|
131
|
+
status="ok",
|
|
132
|
+
retcode=0,
|
|
133
|
+
data=SendMsgRsp(message_id=msgid),
|
|
134
|
+
echo=call.echo
|
|
135
|
+
)
|
|
136
|
+
|
|
137
|
+
elif isinstance(call, SendGroupMessage):
|
|
138
|
+
new_msg = await to_lagrange_msg(
|
|
139
|
+
msg=call.params.message,
|
|
140
|
+
lgrc=self.lag.client,
|
|
141
|
+
target=(TargetInfo(target="group", id=call.params.group_id))
|
|
142
|
+
)
|
|
143
|
+
seq = await self.lag.client.send_grp_msg(
|
|
144
|
+
grp_id=call.params.group_id,
|
|
145
|
+
msg_chain=new_msg
|
|
146
|
+
)
|
|
147
|
+
text = ""
|
|
148
|
+
for i in new_msg:
|
|
149
|
+
text += i.display
|
|
150
|
+
msgid = info_mgr.msgid_mgr.add(
|
|
151
|
+
MsgInfo(
|
|
152
|
+
raw_msg=new_msg,
|
|
153
|
+
scene_type="group",
|
|
154
|
+
scene_id=call.params.group_id,
|
|
155
|
+
seq=seq,
|
|
156
|
+
timestamp=round(time.time()),
|
|
157
|
+
uid=self.lag.client.uid,
|
|
158
|
+
uin=self.lag.client.uin,
|
|
159
|
+
text=text
|
|
160
|
+
)
|
|
161
|
+
)
|
|
162
|
+
rsp = SendGroupMessageResponse(
|
|
163
|
+
status="ok",
|
|
164
|
+
retcode=0,
|
|
165
|
+
data=SendMsgRsp(message_id=msgid),
|
|
166
|
+
echo=call.echo
|
|
167
|
+
)
|
|
168
|
+
|
|
169
|
+
elif isinstance(call, DeleteMessage):
|
|
170
|
+
msgid = call.params.message_id
|
|
171
|
+
msg_info = info_mgr.msgid_mgr.fetch(msgid)
|
|
172
|
+
if msg_info.scene_type == "user":
|
|
173
|
+
pass
|
|
174
|
+
else:
|
|
175
|
+
await self.lag.client.recall_grp_msg(grp_id=msg_info.scene_id, seq=msg_info.seq)
|
|
176
|
+
rsp = DeleteMessageResponse(
|
|
177
|
+
status="ok",
|
|
178
|
+
retcode=0,
|
|
179
|
+
data=EmptyRsp(),
|
|
180
|
+
echo=call.echo
|
|
181
|
+
)
|
|
182
|
+
|
|
183
|
+
elif isinstance(call, GetVersionInfo):
|
|
184
|
+
rsp = GetVersionInfoResponse(
|
|
185
|
+
status="ok",
|
|
186
|
+
retcode=0,
|
|
187
|
+
data=GetVersionInfoRsp(),
|
|
188
|
+
echo=call.echo
|
|
189
|
+
)
|
|
190
|
+
|
|
191
|
+
|
|
192
|
+
elif isinstance(call, GetMessage):
|
|
193
|
+
rsp = ActionFailedResponse(
|
|
194
|
+
status="failed",
|
|
195
|
+
retcode=1400,
|
|
196
|
+
data=EmptyRsp(),
|
|
197
|
+
echo=call.echo
|
|
198
|
+
)
|
|
199
|
+
msg = info_mgr.msgid_mgr.fetch(call.params.message_id)
|
|
200
|
+
if msg.uid:
|
|
201
|
+
user_info = await self.lag.client.get_user_info(msg.uid)
|
|
202
|
+
elif msg.uin:
|
|
203
|
+
user_info = await self.lag.client.get_user_info(msg.uin)[0]
|
|
204
|
+
else:
|
|
205
|
+
user_info = None
|
|
206
|
+
rsp = GetMessageResponse(
|
|
207
|
+
status="ok",
|
|
208
|
+
retcode=0,
|
|
209
|
+
data=GetMsgRsp(
|
|
210
|
+
message=await to_onebot_msg(msg=msg, lgrc=self.lag.client),
|
|
211
|
+
time=msg.timestamp,
|
|
212
|
+
message_id=call.params.message_id,
|
|
213
|
+
message_type="private" if msg.scene_type == "user" else "group",
|
|
214
|
+
real_id=msg.seq,
|
|
215
|
+
sender=onebot_events.PrivateSender(
|
|
216
|
+
user_id=msg.uin,
|
|
217
|
+
nickname="" if not user_info else user_info.name,
|
|
218
|
+
sex=user_info.sex.name if user_info.sex.name != "notset" else "unknown",
|
|
219
|
+
age=0 if not user_info else user_info.age,
|
|
220
|
+
) if msg.scene_type == "user" else onebot_events.GroupSender(
|
|
221
|
+
user_id=msg.uin,
|
|
222
|
+
title="",
|
|
223
|
+
sex=user_info.sex.name if user_info.sex.name != "notset" else "unknown",
|
|
224
|
+
role="member",
|
|
225
|
+
age=0 if not user_info else user_info.age,
|
|
226
|
+
area="" if not user_info else f"{user_info.country} {user_info.province} {user_info.city}",
|
|
227
|
+
card="",
|
|
228
|
+
level="",
|
|
229
|
+
nickname="" if not user_info else user_info.name,
|
|
230
|
+
)
|
|
231
|
+
),
|
|
232
|
+
echo=call.echo
|
|
233
|
+
)
|
|
234
|
+
|
|
235
|
+
|
|
236
|
+
elif isinstance(call, GetGroupInfo):
|
|
237
|
+
grps = await self.lag.client.get_grp_list()
|
|
238
|
+
info = list(filter(lambda x: x.grp_id == call.params.group_id, grps.grp_list))[0]
|
|
239
|
+
rsp = GetGroupInfoResponse(
|
|
240
|
+
status="ok",
|
|
241
|
+
retcode=0,
|
|
242
|
+
data=GetGroupInfoRsp(
|
|
243
|
+
group_id=call.params.group_id,
|
|
244
|
+
member_count=info.info.now_members,
|
|
245
|
+
max_member_count=info.info.max_members,
|
|
246
|
+
group_name=info.info.grp_name
|
|
247
|
+
),
|
|
248
|
+
echo=call.echo
|
|
249
|
+
)
|
|
250
|
+
|
|
251
|
+
|
|
252
|
+
elif isinstance(call, GetStrangerInfo):
|
|
253
|
+
try:
|
|
254
|
+
uid = info_mgr.uid_mgr.from_uin(call.params.user_id)
|
|
255
|
+
except KeyError:
|
|
256
|
+
uid = None
|
|
257
|
+
info = await self.lag.client.get_user_info(uid or call.params.user_id)
|
|
258
|
+
rsp = GetStrangerInfoResponse(
|
|
259
|
+
status="ok",
|
|
260
|
+
retcode=0,
|
|
261
|
+
data=GetStrangerInfoRsp(
|
|
262
|
+
age=info.age,
|
|
263
|
+
nickname=info.name,
|
|
264
|
+
sex=info.sex.name if info.sex.name != "notset" else "unknown",
|
|
265
|
+
user_id=call.params.user_id
|
|
266
|
+
),
|
|
267
|
+
echo=call.echo
|
|
268
|
+
)
|
|
269
|
+
else:
|
|
270
|
+
rsp = ActionFailedResponse(
|
|
271
|
+
status="failed",
|
|
272
|
+
retcode=1404,
|
|
273
|
+
data=EmptyRsp(),
|
|
274
|
+
echo=call.echo
|
|
275
|
+
)
|
|
276
|
+
await self.adapter.report(rsp)
|
|
277
|
+
except Exception as e:
|
|
278
|
+
logger.error(repr(e))
|
|
279
|
+
logger.error(traceback.format_exc())
|
|
280
|
+
rsp = ActionFailedResponse(
|
|
281
|
+
status="failed",
|
|
282
|
+
retcode=1400,
|
|
283
|
+
data=EmptyRsp(),
|
|
284
|
+
echo=call.echo
|
|
285
|
+
)
|
|
286
|
+
await self.adapter.report(rsp)
|
|
287
|
+
|
|
288
|
+
async def grp_msg_handler(self, client: Client, event: GroupMessage) -> None:
|
|
289
|
+
if event.uin == self.lag.client.uin:
|
|
290
|
+
return
|
|
291
|
+
logger.info(f"[Group] {event.grp_name}({event.grp_id}): @{event.nickname}({event.uin}): {event.msg}")
|
|
292
|
+
if not info_mgr.uid_mgr.is_exist(event.uid):
|
|
293
|
+
info_mgr.uid_mgr.add(event.uid, event.uin)
|
|
294
|
+
guser_info = (await client.get_grp_member_info(event.grp_id, event.uid)).body[0]
|
|
295
|
+
user_info = await client.get_user_info(event.uid)
|
|
296
|
+
if guser_info.is_owner:
|
|
297
|
+
role = "owner"
|
|
298
|
+
elif guser_info.is_admin:
|
|
299
|
+
role = "admin"
|
|
300
|
+
else:
|
|
301
|
+
role = "member"
|
|
302
|
+
ev = onebot_events.GroupMessageEvent(
|
|
303
|
+
time=event.time,
|
|
304
|
+
self_id=self.lag.client.uin,
|
|
305
|
+
message_id=info_mgr.msgid_mgr.add(
|
|
306
|
+
MsgInfo(
|
|
307
|
+
raw_msg=event.msg_chain,
|
|
308
|
+
scene_type="group",
|
|
309
|
+
scene_id=event.grp_id,
|
|
310
|
+
seq=event.seq,
|
|
311
|
+
timestamp=event.time,
|
|
312
|
+
uin=event.uin,
|
|
313
|
+
uid=event.uid,
|
|
314
|
+
text=event.msg
|
|
315
|
+
)
|
|
316
|
+
),
|
|
317
|
+
user_id=event.uin,
|
|
318
|
+
message=await to_onebot_msg(event=event, lgrc=self.lag.client),
|
|
319
|
+
group_id=event.grp_id,
|
|
320
|
+
raw_message=event.msg,
|
|
321
|
+
sender=onebot_events.GroupSender(
|
|
322
|
+
age=user_info.age,
|
|
323
|
+
area=f"{user_info.country} {user_info.province} {user_info.city}",
|
|
324
|
+
card="" if not guser_info.name else guser_info.name.string,
|
|
325
|
+
level="" if not guser_info.level else str(guser_info.level.num),
|
|
326
|
+
nickname=user_info.name,
|
|
327
|
+
role=role, # type: ignore
|
|
328
|
+
sex="unknown",
|
|
329
|
+
title="",
|
|
330
|
+
user_id=event.uin
|
|
331
|
+
)
|
|
332
|
+
)
|
|
333
|
+
await self.adapter.trigger(ev)
|
|
334
|
+
|
|
335
|
+
async def pri_msg_handler(self, client: Client, event: FriendMessage) -> None:
|
|
336
|
+
if event.from_uin == self.lag.client.uin:
|
|
337
|
+
return
|
|
338
|
+
logger.info(f"[Friend] {event.from_uin} -> {event.to_uin}: {event.msg}")
|
|
339
|
+
if not info_mgr.uid_mgr.is_exist(event.from_uid):
|
|
340
|
+
info_mgr.uid_mgr.add(event.from_uid, event.from_uin)
|
|
341
|
+
user_info = await client.get_user_info(event.from_uid)
|
|
342
|
+
ev = onebot_events.PrivateMessageEvent(
|
|
343
|
+
time=event.timestamp,
|
|
344
|
+
self_id=self.lag.client.uin,
|
|
345
|
+
message_id=info_mgr.msgid_mgr.add(
|
|
346
|
+
MsgInfo(
|
|
347
|
+
raw_msg=event.msg_chain,
|
|
348
|
+
scene_type="user",
|
|
349
|
+
scene_id=event.from_uin,
|
|
350
|
+
seq=event.seq,
|
|
351
|
+
timestamp=event.timestamp,
|
|
352
|
+
uin=event.from_uin,
|
|
353
|
+
uid=event.from_uid,
|
|
354
|
+
text=event.msg
|
|
355
|
+
)
|
|
356
|
+
),
|
|
357
|
+
user_id=event.from_uin,
|
|
358
|
+
message=await to_onebot_msg(event=event, lgrc=self.lag.client),
|
|
359
|
+
raw_message=event.msg,
|
|
360
|
+
sender=onebot_events.PrivateSender(
|
|
361
|
+
age=user_info.age,
|
|
362
|
+
nickname=user_info.name,
|
|
363
|
+
sex=user_info.sex.name if user_info.sex.name != "notset" else "unknown", # type: ignore
|
|
364
|
+
user_id=event.from_uin
|
|
365
|
+
)
|
|
366
|
+
)
|
|
367
|
+
await self.adapter.trigger(ev)
|
|
368
|
+
|
|
369
|
+
async def grp_recall_handler(self, client: Client, event: GroupRecall) -> None:
|
|
370
|
+
logger.info(f"[Group] {event.grp_id}: message {event.seq} had been deleted")
|
|
371
|
+
msgid = info_mgr.msgid_mgr.search(
|
|
372
|
+
MsgInfo(
|
|
373
|
+
scene_id=event.grp_id,
|
|
374
|
+
scene_type="group",
|
|
375
|
+
seq=event.seq
|
|
376
|
+
)
|
|
377
|
+
)
|
|
378
|
+
if not msgid:
|
|
379
|
+
return
|
|
380
|
+
real_info = info_mgr.msgid_mgr.fetch(msgid)
|
|
381
|
+
ev = onebot_events.GroupRecallEvent(
|
|
382
|
+
group_id=event.grp_id,
|
|
383
|
+
message_id=msgid,
|
|
384
|
+
operator_id=0,
|
|
385
|
+
self_id=self.lag.client.uin,
|
|
386
|
+
time=event.time,
|
|
387
|
+
user_id=real_info.uin
|
|
388
|
+
)
|
|
389
|
+
await self.adapter.trigger(ev)
|
|
390
|
+
|
|
391
|
+
async def pri_recall_handler(self, client: Client, event: FriendRecall) -> None:
|
|
392
|
+
if event.from_uin == self.lag.client.uin:
|
|
393
|
+
return
|
|
394
|
+
logger.info(f"[Friend] {event.from_uin} -> {event.to_uin}: message {event.seq} had been deleted")
|
|
395
|
+
msgid = info_mgr.msgid_mgr.search(
|
|
396
|
+
MsgInfo(
|
|
397
|
+
scene_id=event.from_uin,
|
|
398
|
+
scene_type="user",
|
|
399
|
+
seq=event.seq
|
|
400
|
+
)
|
|
401
|
+
)
|
|
402
|
+
if not msgid:
|
|
403
|
+
return
|
|
404
|
+
ev = onebot_events.FriendRecallEvent(
|
|
405
|
+
message_id=msgid,
|
|
406
|
+
self_id=self.lag.client.uin,
|
|
407
|
+
time=event.timestamp,
|
|
408
|
+
user_id=event.from_uin
|
|
409
|
+
)
|
|
410
|
+
await self.adapter.trigger(ev)
|
|
411
|
+
|
|
412
|
+
async def grp_mute_handler(self, client: Client, event: GroupMuteMember) -> None:
|
|
413
|
+
logger.info(
|
|
414
|
+
f"[Group] {event.grp_id}: member {event.target_uid} had been muted by {event.operator_uid} for {event.duration}s")
|
|
415
|
+
try:
|
|
416
|
+
opt_uin = info_mgr.uid_mgr.from_uid(event.operator_uid)
|
|
417
|
+
uin = 0 if not event.target_uid else info_mgr.uid_mgr.from_uid(event.target_uid)
|
|
418
|
+
except ValueError:
|
|
419
|
+
return
|
|
420
|
+
ev = onebot_events.GroupMuteEvent(
|
|
421
|
+
duration=event.duration,
|
|
422
|
+
group_id=event.grp_id,
|
|
423
|
+
operator_id=opt_uin,
|
|
424
|
+
self_id=self.lag.client.uin,
|
|
425
|
+
sub_type="lift_ban" if event.duration == 0 else "ban",
|
|
426
|
+
time=round(time.time()),
|
|
427
|
+
user_id=uin
|
|
428
|
+
)
|
|
429
|
+
await self.adapter.trigger(ev)
|
|
430
|
+
|
|
431
|
+
async def grp_join_handler(self, client: Client, event: GroupMemberJoined) -> None:
|
|
432
|
+
logger.info(f"[Group] {event.grp_id}: member {event.uid} has joined")
|
|
433
|
+
try:
|
|
434
|
+
uin = info_mgr.uid_mgr.from_uid(event.uid)
|
|
435
|
+
except ValueError:
|
|
436
|
+
rs = await client.get_grp_member_info(grp_id=event.grp_id, uid=event.uid)
|
|
437
|
+
uin = rs.body[0].account.uin or 0
|
|
438
|
+
if uin:
|
|
439
|
+
info_mgr.uid_mgr.add(event.uid, uin)
|
|
440
|
+
ev = onebot_events.GroupIncreaseEvent(
|
|
441
|
+
group_id=event.grp_id,
|
|
442
|
+
operator_id=0,
|
|
443
|
+
self_id=self.lag.client.uin,
|
|
444
|
+
sub_type="approve",
|
|
445
|
+
time=round(time.time()),
|
|
446
|
+
user_id=uin
|
|
447
|
+
)
|
|
448
|
+
await self.adapter.trigger(ev)
|
|
449
|
+
|
|
450
|
+
async def grp_invite_join_handler(self, client: Client, event: GroupMemberJoinedByInvite) -> None:
|
|
451
|
+
logger.info(f"[Group] {event.grp_id}: member {event.uin} has joined, invited by {event.invitor_uin}")
|
|
452
|
+
ev = onebot_events.GroupIncreaseEvent(
|
|
453
|
+
group_id=event.grp_id,
|
|
454
|
+
operator_id=event.invitor_uin,
|
|
455
|
+
self_id=self.lag.client.uin,
|
|
456
|
+
sub_type="invite",
|
|
457
|
+
time=round(time.time()),
|
|
458
|
+
user_id=event.uin
|
|
459
|
+
)
|
|
460
|
+
await self.adapter.trigger(ev)
|
|
461
|
+
|
|
462
|
+
async def grp_quit_handler(self, client: Client, event: GroupMemberQuit) -> None:
|
|
463
|
+
logger.info(
|
|
464
|
+
f"[Group] {event.grp_id}: member {event.uin} has left{', kicked by ' + str(event.operator_uid) if event.is_kicked else ''}")
|
|
465
|
+
opt_uin = 0
|
|
466
|
+
if event.is_kicked or event.is_kicked_self:
|
|
467
|
+
try:
|
|
468
|
+
opt_uin = info_mgr.uid_mgr.from_uid(event.operator_uid)
|
|
469
|
+
except ValueError:
|
|
470
|
+
opt_uin = 0
|
|
471
|
+
if event.is_kicked_self:
|
|
472
|
+
tp = "kick_me"
|
|
473
|
+
elif event.is_kicked:
|
|
474
|
+
tp = "kick"
|
|
475
|
+
else:
|
|
476
|
+
tp = "leave"
|
|
477
|
+
if not info_mgr.uid_mgr.is_exist(event.uin):
|
|
478
|
+
info_mgr.uid_mgr.add(event.uid, event.uin)
|
|
479
|
+
ev = onebot_events.GroupDecreaseEvent(
|
|
480
|
+
group_id=event.grp_id,
|
|
481
|
+
operator_id=opt_uin,
|
|
482
|
+
self_id=self.lag.client.uin,
|
|
483
|
+
sub_type=tp, # type: ignore
|
|
484
|
+
time=round(time.time()),
|
|
485
|
+
user_id=event.uin
|
|
486
|
+
)
|
|
487
|
+
await self.adapter.trigger(ev)
|
|
488
|
+
|
|
489
|
+
async def poke_handler(self, client: Client, event: GroupNudge) -> None:
|
|
490
|
+
ev = onebot_events.GroupPokeEvent(
|
|
491
|
+
time=round(time.time()),
|
|
492
|
+
self_id=self.lag.client.uin,
|
|
493
|
+
group_id=event.grp_id,
|
|
494
|
+
user_id=event.sender_uin,
|
|
495
|
+
target_id=event.target_uin
|
|
496
|
+
)
|
|
497
|
+
await self.adapter.trigger(ev)
|
|
498
|
+
|
|
499
|
+
async def reaction_handler(self, client: Client, event: GroupReaction) -> None:
|
|
500
|
+
try:
|
|
501
|
+
if event.uid:
|
|
502
|
+
uid = event.uid
|
|
503
|
+
uin = info_mgr.uid_mgr.from_uid(event.uid)
|
|
504
|
+
else:
|
|
505
|
+
uid = info_mgr.uid_mgr.from_uin(event.uin)
|
|
506
|
+
uin = event.uin
|
|
507
|
+
except KeyError:
|
|
508
|
+
if event.uid:
|
|
509
|
+
uid = event.uid
|
|
510
|
+
uin = 0
|
|
511
|
+
else:
|
|
512
|
+
uid = ""
|
|
513
|
+
uin = event.uin
|
|
514
|
+
try:
|
|
515
|
+
msgid = info_mgr.msgid_mgr.search(MsgInfo(scene_type="group", scene_id=event.grp_id, seq=event.seq))
|
|
516
|
+
except IndexError:
|
|
517
|
+
msgid = info_mgr.msgid_mgr.add(
|
|
518
|
+
MsgInfo(scene_type="group", scene_id=event.grp_id, seq=event.seq, uid=uid, uin=uin))
|
|
519
|
+
ev = onebot_events.ReactionEvent(
|
|
520
|
+
time=round(time.time()),
|
|
521
|
+
self_id=self.lag.client.uin,
|
|
522
|
+
message_id=msgid,
|
|
523
|
+
operator_id=uin,
|
|
524
|
+
sub_type="add" if event.is_increase else "remove",
|
|
525
|
+
code=event.emoji_id,
|
|
526
|
+
count=event.emoji_count
|
|
527
|
+
)
|
|
528
|
+
await self.adapter.trigger(ev)
|