async def respondRequest(
self,
request: T.Union[eem.BotInvitedJoinGroupRequestEvent, # 新增
eem.NewFriendRequestEvent,
eem.MemberJoinRequestEvent],
operate: T.Union[BotInvitedJoinGroupRequestResponseOperate,
NewFriendRequestResponseOperate,
MemberJoinRequestResponseOperate, int],
message: T.Optional[str] = ""):
"""回应请求, 请求指 `添加好友请求` 或 `申请加群请求`."""
if isinstance(request, eem.BotInvitedJoinGroupRequestEvent): # 新增
if not isinstance(
operate, (BotInvitedJoinGroupRequestResponseOperate, int)):
raise TypeError(f"unknown operate: {operate}")
operate = (operate.value if isinstance(
operate, BotInvitedJoinGroupRequestResponseOperate) else
operate)
return assertOperatorSuccess(await fetch.http_post(
f"{self.baseurl}/resp/botInvitedJoinGroupRequestEvent", {
"sessionKey": self.session_key,
"eventId": request.requestId,
"fromId": request.supplicant,
"groupId": request.sourceGroup,
"operate": operate,
"message": message
}),
raise_exception=True)
elif isinstance(request, eem.NewFriendRequestEvent):
if not isinstance(operate, (NewFriendRequestResponseOperate, int)):
raise TypeError(f"unknown operate: {operate}")
operate = (operate.value if isinstance(
operate, NewFriendRequestResponseOperate) else operate)
return assertOperatorSuccess(await fetch.http_post(
f"{self.baseurl}/resp/newFriendRequestEvent", {
"sessionKey": self.session_key,
"eventId": request.requestId,
"fromId": request.supplicant,
"groupId": request.sourceGroup,
"operate": operate,
"message": message
}),
raise_exception=True)
elif isinstance(request, eem.MemberJoinRequestEvent):
if not isinstance(operate,
(MemberJoinRequestResponseOperate, int)):
raise TypeError(f"unknown operate: {operate}")
operate = (operate.value if isinstance(
operate, MemberJoinRequestResponseOperate) else operate)
return assertOperatorSuccess(await fetch.http_post(
f"{self.baseurl}/resp/memberJoinRequestEvent", {
"sessionKey": self.session_key,
"eventId": request.requestId,
"fromId": request.supplicant,
"groupId": request.sourceGroup,
"operate": operate,
"message": message
}),
raise_exception=True)
else:
raise TypeError(f"unknown request: {request}")
async def revokeMessage(self, source: T.Union[components.Source, int]):
return assertOperatorSuccess(await fetch.http_post(
f"{self.baseurl}/recall", {
"sessionKey": self.session_key,
"target": source if isinstance(source, int) else source.id
}),
raise_exception=True)
async def verify(self):
return assertOperatorSuccess(
await fetch.http_post(f"{self.baseurl}/verify", {
"sessionKey": self.session_key,
"qq": self.qq
}
), raise_exception=True, return_as_is=True)
async def fetchMessage(self, count: int) -> T.List[T.Union[FriendMessage, GroupMessage, ExternalEvent]]:
from mirai.event.external.enums import ExternalEvents
result = assertOperatorSuccess(
await fetch.http_get(f"{self.baseurl}/fetchMessage", {
"sessionKey": self.session_key,
"count": count
}
), raise_exception=True, return_as_is=True)['data']
# 因为重新生成一个开销太大, 所以就直接在原数据内进行遍历替换
try:
for index in range(len(result)):
# 判断当前项是否为 Message
if result[index]['type'] in MessageTypes:
if 'messageChain' in result[index]:
result[index]['messageChain'] = MessageChain.parse_obj(result[index]['messageChain'])
result[index] = \
MessageTypes[result[index]['type']].parse_obj(result[index])
elif hasattr(ExternalEvents, result[index]['type']):
# 判断当前项为 Event
result[index] = \
ExternalEvents[result[index]['type']].value.parse_obj(result[index])
except pydantic.ValidationError:
ProtocolLogger.error(f"parse failed: {result}")
traceback.print_exc()
raise
return result
async def release(self):
return assertOperatorSuccess(
await fetch.http_post(f"{self.baseurl}/release", {
"sessionKey": self.session_key,
"qq": self.qq
}
), raise_exception=True)
async def unmuteAll(self, group: T.Union[Group, int]) -> bool:
return assertOperatorSuccess(
await fetch.http_post(f"{self.baseurl}/unmuteAll", {
"sessionKey": self.session_key,
"target": self.handleTargetAsGroup(group)
}
), raise_exception=True)
async def revokeMessage(self, source: T.Union[components.Source, BotMessage, int]):
return assertOperatorSuccess(await fetch.http_post(f"{self.baseurl}/recall", {
"sessionKey": self.session_key,
"target": source if isinstance(source, int) else source.id \
if isinstance(source, components.Source) else source.messageId\
if isinstance(source, BotMessage) else\
raiser(TypeError("invaild message source"))
}), raise_exception=True)
async def groupMkdir(self, target: int, dir_name: str):
return assertOperatorSuccess(await fetch.http_post(
f"{self.baseurl}/groupMkdir", {
"sessionKey": self.session_key,
"target": target,
"dir": dir_name
}),
raise_exception=True)
async def groupDeleteFile(self, target: int, id: str):
return assertOperatorSuccess(await fetch.http_post(
f"{self.baseurl}/groupFileDelete", {
"sessionKey": self.session_key,
"target": target,
"id": id
}),
raise_exception=True)
async def unmute(self, group: T.Union[Group, int], member: T.Union[Member,
int]):
return assertOperatorSuccess(await fetch.http_post(
f"{self.baseurl}/unmute", {
"sessionKey": self.session_key,
"target": self.handleTargetAsGroup(group),
"memberId": self.handleTargetAsMember(member),
}),
raise_exception=True)
async def changeGroupConfig(self, group: T.Union[Group, int],
config: GroupSetting) -> bool:
return assertOperatorSuccess(await fetch.http_post(
f"{self.baseurl}/groupConfig", {
"sessionKey": self.session_key,
"target": self.handleTargetAsGroup(group),
"config": json.loads(config.json())
}),
raise_exception=True)
async def sendCommand(self, command, *args):
return assertOperatorSuccess(await fetch.http_post(
f"{self.baseurl}/command/send", {
"authKey": self.auth_key,
"name": command,
"args": args
}),
raise_exception=True,
return_as_is=True)
async def quit(
self, # 新增
group: T.Union[Group, int]):
return assertOperatorSuccess(await fetch.http_post(
f"{self.baseurl}/quit", {
"sessionKey": self.session_key,
"target": self.handleTargetAsGroup(group)
}),
raise_exception=True)
async def memberInfo(self,
group: T.Union[Group, int],
member: T.Union[Member, int]
):
return MemberChangeableSetting.parse_obj(assertOperatorSuccess(
await fetch.http_get(f"{self.baseurl}/memberInfo", {
"sessionKey": self.session_key,
"target": self.handleTargetAsGroup(group),
"memberId": self.handleTargetAsMember(member)
}
), raise_exception=True, return_as_is=True))
async def changeMemberInfo(self, group: T.Union[Group, int],
member: T.Union[Member, int],
setting: MemberChangeableSetting) -> bool:
return assertOperatorSuccess(await fetch.http_post(
f"{self.baseurl}/memberInfo", {
"sessionKey": self.session_key,
"target": self.handleTargetAsGroup(group),
"memberId": self.handleTargetAsMember(member),
"info": json.loads(setting.json())
}),
raise_exception=True)
async def setConfig(self, cacheSize=None, enableWebsocket=None):
return assertOperatorSuccess(await fetch.http_post(
f"{self.baseurl}/config", {
"sessionKey": self.session_key,
**({
"cacheSize": cacheSize
} if cacheSize else {}),
**({
"enableWebsocket": enableWebsocket
} if enableWebsocket else {})
}),
raise_exception=True,
return_as_is=True)
async def kick(self,
group: T.Union[Group, int],
member: T.Union[Member, int],
kickMessage: T.Optional[str] = None):
return assertOperatorSuccess(await fetch.http_post(
f"{self.baseurl}/kick", {
"sessionKey": self.session_key,
"target": self.handleTargetAsGroup(group),
"memberId": self.handleTargetAsMember(member),
**({
"msg": kickMessage
} if kickMessage else {})
}),
raise_exception=True)
async def nudge(self, type: T.Union[str, NudgeType], subject: int,
target: int):
type = type if isinstance(type, str) else type.value
return assertOperatorSuccess(
await fetch.http_post(
f"{self.baseurl}/sendNudge",
{
"sessionKey": self.session_key,
"target": target,
"subject": subject,
"kind": '{}{}'.format(type[0].upper(),
type[1:]) # 不知道为什么现在需要首字母大写
}),
raise_exception=True)
async def sendFriendMessage(
self, friend: T.Union[Friend, int],
message: T.Union[MessageChain, BaseMessageComponent,
T.List[BaseMessageComponent], str]
) -> BotMessage:
return BotMessage.parse_obj(
assertOperatorSuccess(await fetch.http_post(
f"{self.baseurl}/sendFriendMessage", {
"sessionKey": self.session_key,
"target": self.handleTargetAsFriend(friend),
"messageChain": await self.handleMessageAsFriend(message)
}),
raise_exception=True,
return_as_is=True))
async def mute(self, group: T.Union[Group, int],
member: T.Union[Member, int], time: T.Union[timedelta,
int]):
if isinstance(time, timedelta):
time = int(time.total_seconds())
time = min(86400 * 30, max(60, time))
return assertOperatorSuccess(await fetch.http_post(
f"{self.baseurl}/mute", {
"sessionKey": self.session_key,
"target": self.handleTargetAsGroup(group),
"memberId": self.handleTargetAsMember(member),
"time": time
}),
raise_exception=True)
async def sendGroupMessage(
self,
group: T.Union[Group, int],
message: T.Union[MessageChain, BaseMessageComponent,
T.List[BaseMessageComponent], str],
quoteSource: T.Union[int, components.Source] = None) -> BotMessage:
return BotMessage.parse_obj(assertOperatorSuccess(
await fetch.http_post(f"{self.baseurl}/sendGroupMessage", {
"sessionKey": self.session_key,
"target": self.handleTargetAsGroup(group),
"messageChain": await self.handleMessageAsGroup(message),
**({"quote": quoteSource.id \
if isinstance(quoteSource, components.Source) else quoteSource}\
if quoteSource else {})
}
), raise_exception=True, return_as_is=True))
async def messageFromId(self, sourceId: T.Union[components.Source, components.Quote, int]):
if isinstance(sourceId, (components.Source, components.Quote)):
sourceId = sourceId.id
result = assertOperatorSuccess(await fetch.http_get(f"{self.baseurl}/messageFromId", {
"sessionKey": self.session_key,
"id": sourceId
}), raise_exception=True, return_as_is=True)
if result['type'] in MessageTypes:
if "messageChain" in result:
result['messageChain'] = MessageChain.custom_parse(result['messageChain'])
return MessageTypes[result['type']].parse_obj(result)
else:
raise TypeError(f"unknown message, not found type.")
async def fetchMessage(self, count: int) -> T.List[T.Union[FriendMessage, GroupMessage, ExternalEvent]]:
result = assertOperatorSuccess(
await fetch.http_get(f"{self.baseurl}/fetchMessage", {
"sessionKey": self.session_key,
"count": count
}
), raise_exception=True, return_as_is=True)
for index in range(len(result)): # 因为重新生成一个开销太大, 所以就直接在原数据内进行遍历替换
if result[index]['type'] in MessageTypes: # 判断当前项是否为 Message
if 'messageChain' in result[index]: # 使用 custom_parse 方法处理消息链
result[index]['messageChain'] = MessageChain.custom_parse(result[index]['messageChain'])
result[index] = \
MessageTypes[result[index]['type']].parse_obj(result[index])
elif hasattr(ExternalEvents, result[index]['type']): # 判断当前项是否为 Event
result[index] = \
ExternalEvents[result[index]['type']].value.parse_obj(result[index])
return result
async def sendTempMessage(
self,
group: T.Union[Group, int],
member: T.Union[Member, int],
message: T.Union[MessageChain, BaseMessageComponent,
T.List[T.Union[BaseMessageComponent,
InternalImage]], str],
quoteSource: T.Union[int, components.Source] = None) -> BotMessage:
return BotMessage.parse_obj(assertOperatorSuccess(
await fetch.http_post(f"{self.baseurl}/sendTempMessage", {
"sessionKey": self.session_key,
"qq": (member.id if isinstance(member, Member) else member),
"group": (group.id if isinstance(group, Group) else group),
"messageChain": await self.handleMessageForTempMessage(message),
**({"quote": quoteSource.id \
if isinstance(quoteSource, components.Source) else quoteSource}\
if quoteSource else {})
}
), raise_exception=True, return_as_is=True))
async def mute(self, group: T.Union[Group, int],
member: T.Union[Member, int], time: T.Union[timedelta,
int]):
return assertOperatorSuccess(
await fetch.http_post(f"{self.baseurl}/mute", {
"sessionKey": self.session_key,
"target": self.handleTargetAsGroup(group),
"memberId": self.handleTargetAsMember(member),
"time": time if isinstance(time, int) else \
int(time.total_seconds()) \
if timedelta(days=30) >= time >= timedelta(minutes=1) \
else \
int(timedelta(days=30).total_seconds()) \
if timedelta(days=30) >= time else \
int(timedelta(minutes=1).total_seconds()) \
if time <= timedelta(minutes=1) else \
raiser(ValueError("invaild time."))
if isinstance(time, timedelta) else raiser(ValueError("invaild time."))
}
), raise_exception=True)
async def getConfig(self) -> dict:
return assertOperatorSuccess(
await fetch.http_get(f"{self.baseurl}/config", {
"sessionKey": self.session_key
}
), raise_exception=True, return_as_is=True)
async def auth(self):
return assertOperatorSuccess(
await fetch.http_post(f"{self.baseurl}/auth", {
"authKey": self.auth_key
}
), raise_exception=True, return_as_is=True)
async def getManagers(self):
return assertOperatorSuccess(await fetch.http_get(f"{self.baseurl}/managers"))
