async def _(bot: Bot, event: Event, state: dict):
""" 如果在群里发送，则在当前群禁言/解除 """
if event.detail_type == 'group':
group_id = state['group_id']
user_id = state['user_id']
duration = state['duration']
duration_sec = duration * 60
bot_role = _bot_role[group_id]
sender_role = event.sender['role']
ban_type = get_ban_type(bot_role, sender_role)
if ban_type == BanType.OWNER:
await ban_cmd.finish(render_expression(EXPR_OWNER), at_sender=True)
elif ban_type == BanType.NEED_HELP:
owner_id = await get_owner_id(group_id, bot)
if not owner_id:
raise Exception('无法获取群主QQ号')
await ban_cmd.finish(
render_expression(
EXPR_NEED_HELP,
duration=duration,
at_owner=MessageSegment.at(owner_id),
at_user=MessageSegment.at(user_id)
)
)
else:
await bot.set_group_ban(
group_id=group_id, user_id=user_id, duration=duration_sec
)
await ban_cmd.finish(
render_expression(EXPR_OK, duration=duration), at_sender=True
)
async def decherulize_cheru(bot: Bot, event: Event, state: dict):
msg = state['cheru']
uid = event.user_id
at = MessageSegment.at(uid)
res = escape(cheru2str(msg))
result = f'{at}的切噜噜是：\n{res}'
await sv_cheru_to_txt.finish(result)
async def _(bot: Bot, event: GroupRecallNoticeEvent):
mid = event.message_id
meg = await bot.get_msg(message_id=mid)
if event.user_id != event.self_id and 'type=flash,' not in meg['message']:
re = 'Killer Queen! 第三の爆弾! Bite The Dust!\n{0}刚刚说了:\n' + meg['message']
await recall.finish(
message=Message(re.format(MessageSegment.at(event.user_id))))
async def wakuang_got(bot: Bot, event: Event, state: dict):
rank = state['rank']
rank = np.clip(rank, 1, 15001)
s_all = all_season[1:rank].sum()
s_this = this_season[1:rank].sum()
uid = event.user_id
at = MessageSegment.at(uid)
msg = f'{at}\n最高排名奖励还剩{s_this}钻\n历届最高排名还剩{s_all}钻'
await sv_wakuang.finish(msg)
async def handle(bot: Bot, event: MessageEvent, state: T_State):
raw_args = str(event.get_message()).strip()
argc = 0
if raw_args:
arg_list = raw_args.split()
argc = len(arg_list)
for i in range(argc):
state[f"arg{i+1}"] = arg_list[i]
if argc > 0 and state["arg1"] == "日榜":
is_timeout, is_error, status, data = await get_image_data_v1(
url="https://rakuen.thec.me/PixivRss/daily-10")
elif argc > 0 and state["arg1"] == "周榜":
is_timeout, is_error, status, data = await get_image_data_v1(
url="http://rakuen.thec.me/PixivRss/weekly-10")
elif argc > 0 and state["arg1"] == "月榜":
is_timeout, is_error, status, data = await get_image_data_v1(
url="https://rakuen.thec.me/PixivRss/monthly-10")
elif argc > 0:
keyword = unescape(state["arg1"])
await pixiv.send(f"正在搜索[{keyword}]……")
is_timeout, is_error, status, data = await get_image_data_v2(
tag=keyword)
else:
is_timeout, is_error, status, data = await get_image_data_v2()
uid = event.user_id
session_id = event.get_session_id().split("_")
# 消息来自群聊
if len(session_id) == 3:
at = MessageSegment.at(uid) + "\n"
else:
at = ""
if is_timeout:
await pixiv.finish(at + "苦しい……请求超时了(´。＿。｀)")
if status != 200 and status != 0:
await pixiv.finish(at + f"苦しい……连接出错了({status})，可以马上重试一下呢！")
if is_error:
await pixiv.finish(at + "苦しい……连接出错了(´。＿。｀)")
elif len(data) == 0:
await pixiv.finish(at + "寂しい……什么都没找到呢。试试范围更大的关键词哦！")
else:
chosen = choice(data)
try:
await pixiv.send(at + f"{chosen[0]}\nPixiv 链接：{chosen[1]}\n" +
MessageSegment.image(chosen[2]) +
"可能会发不出图片呜呜，复制下面链接到浏览器查看吧")
except ActionFailed as e:
await pixiv.send(
at +
f"{chosen[0]}\nPixiv 链接：{chosen[1]}\n大概是太涩了差点发不出来，复制下面链接到浏览器查看吧"
)
print(f"[pixiv.py]: {e}")
finally:
await pixiv.finish(await async_shorten_url(chosen[2]))
async def format_keys(self, more: dict = None) -> dict:
"""
获取新加入用户的信息进行回复
"""
more = more or {}
user_info = await self.bot.get_group_member_info(group_id=self.event.group_id, user_id=self.event.user_id)
return await super(Increase, self).format_keys({
"name": user_info["nickname"],
"sex": user_info["sex"],
"at": MessageSegment.at(user_info["user_id"]),
**more})
async def _(bot: Bot, event: Event, state: dict):
""" 如果私聊的话，则向用户请求群号，并仅在支持的群禁言/解除 """
if event.detail_type == 'private':
group_id = state['group_id']
user_id = state['user_id']
duration = state['duration']
duration_sec = duration * 60
if group_id not in _bot_role:
await ban_cmd.finish('抱歉，我不在那个群里，帮不了你 >_<')
bot_role = _bot_role[group_id]
sender_role = await get_user_role_in_group(user_id, group_id, bot)
ban_type = get_ban_type(bot_role, sender_role)
if ban_type == BanType.OWNER:
await ban_cmd.finish(render_expression(EXPR_OWNER))
elif ban_type == BanType.NEED_HELP:
owner_id = await get_owner_id(group_id, bot)
if not owner_id:
raise Exception('无法获取群主QQ号')
await bot.send_group_msg(
group_id=group_id,
message=render_expression(
EXPR_NEED_HELP,
duration=duration,
at_owner=MessageSegment.at(owner_id),
at_user=MessageSegment.at(user_id)
)
)
await ban_cmd.finish('帮你@群主了，请耐心等待。')
else:
await bot.set_group_ban(
group_id=group_id, user_id=user_id, duration=duration_sec
)
await ban_cmd.finish(render_expression(EXPR_OK, duration=duration))
async def handle_morning(bot: Bot, event: MessageEvent):
session_id = event.get_session_id().split("_")
gid = int(session_id[1])
uid = int(event.get_user_id())
time = datetime.now()
date = time.date()
# 起床时间储存到前一天的数据里
date -= timedelta(days=1)
# 0:00 ~ 3:00 及 14:00 ~ 24:00 拒绝命令
if time.hour < 3 or time.hour >= 14:
await good_morning.finish("早上好……诶！怎么想都不太对吧！")
return
# 存入起床时间
if gid in data:
if date in data[gid]:
if uid in data[gid][date]:
# 如果已有起床时间，不作理会
if data[gid][date][uid][1] != -1:
await good_morning.finish(
"你已经跟小丛雨说过早上好啦！难道睡回笼觉了吗，要是这样小丛雨可要批评你了！")
return
data[gid][date][uid][1] = time
else:
data[gid][date][uid] = [-1, time]
data[gid][date][-1][1] += 1
else:
data[gid][date] = {-1: [0, 1], uid: [-1, time]}
else:
data[gid] = {date: {-1: [0, 1], uid: [-1, time]}}
save_to_file(data)
time_list = data[gid][date][uid]
order = data[gid][date][-1][1]
if time_list[0] != -1:
delta = time_list[1] - time_list[0]
hours, remains = divmod(delta.seconds, 3600)
mins, secs = divmod(remains, 60)
sleep_time_info = f"昨晚你睡了 {hours} 小时 {mins} 分，是本群起床第 {order} 人！"
else:
sleep_time_info = f"你是本群起床第 {order} 人！没有记录到你昨晚的入睡时间呢，今晚记得跟小丛雨说晚安哦！"
await good_morning.finish(
MessageSegment.at(uid) + "你醒啦！" + sleep_time_info)
async def handle_Chat(bot: Bot, event: Event, state: dict):
try:
if event.group_id:
group_id = event.group_id
except:
group_id = None
# 临时解决串群问题
if group_id != state['group_id']:
if not group_id:
await ELF_bot.reject('你在其他群组的会话未结束呢！')
await ELF_bot.reject()
msg = state["ELF_bot"]
if re.search('再见', msg):
await ELF_bot.send('下次再聊哟！')
return
# 百度
try:
baidu = state['BaiduBot']
r_msg = await baidu.sendMsg(msg)
except:
r_msg = {}
r_msg['code'] = '-1'
if group_id is not None:
res_messages = MessageSegment.at(event.user_id)
else:
res_messages = MessageSegment.text('')
if str(r_msg['code']) != '0':
# 如果出错转为调用腾讯
logger.error(r_msg)
try:
tx = state['TXBot']
r_msg = await tx.sendMsg(msg)
except:
app_id = nonebot.get_driver().config.dict()['tx_app_id']
appkey = nonebot.get_driver().config.dict()['tx_appkey']
session = str(event.user_id)
if app_id == None or appkey == None:
logger.error('腾讯闲聊配置出错！')
await ELF_bot.send('腾讯、百度 闲聊配置出错！请正确配置1')
return
# 腾讯
tx = txbot.TXBot(app_id=app_id, appkey=appkey, session=session)
r_msg = await tx.sendMsg(msg)
await ELF_bot.reject(res_messages +
MessageSegment.text(r_msg['answer']))
else:
await ELF_bot.reject(res_messages +
MessageSegment.text(r_msg['answer']))
async def send(self,
file: str = "",
msg: str = "",
at: bool = False): # 发送图片或文字
# if file[1:4] != "http" and file[1:4] != "": # 本地文件
# file = "file:///" + file
message_segment = list()
if file:
message_segment.append(MessageSegment.image(file=file))
if msg:
message_segment.append(MessageSegment.text(msg))
if at:
message_segment.append(
MessageSegment.at(self.event.dict()["user_id"]))
message = Message(message_segment)
return await self.bot.send(event=self.event, message=message)
async def handle(bot: Bot, event: MessageEvent, state: T_State):
argc = 0
raw_args = str(event.get_message()).strip()
if raw_args:
arg_list = raw_args.split()
argc = len(arg_list)
for i in range(argc):
state[f"arg{i+1}"] = arg_list[i]
# 摇点
if argc <= 1:
is_valid = True
if "arg1" in state:
try:
max_num = int(state["arg1"])
except ValueError:
max_num = -1
if max_num <= 0:
is_valid = False
else:
max_num = 100
if is_valid:
r = randint(0, max_num)
ending = "好耶！"
if r <= round(max_num / 3):
ending = "不会吧不会吧？"
await roll.finish(
MessageSegment.at(event.get_user_id()) + f"摇了 {r}！" + ending)
else:
await roll.finish("小丛雨只会摇正整数哦！")
# 摇选项
else:
# 消去重复选项
arg_list = list(set(arg_list))
if len(arg_list) > 1:
start = ["当然是", "必然", "这不得"]
end = ["啦！", "。", "？"]
r = randint(0, len(start) - 1)
await roll.finish(f"{start[r]}{choice(arg_list)}{end[r]}")
else:
await roll.finish(f"只能是{arg_list[0]}了！你根本就没想让小丛雨帮你决定，哼！")
async def handle_night(bot: Bot, event: MessageEvent):
session_id = event.get_session_id().split("_")
gid = int(session_id[1])
uid = int(event.get_user_id())
time = datetime.now()
date = time.date()
# 5:00 ~ 21:00 拒绝命令
if 5 <= time.hour < 21:
await good_night.finish("太早啦，还没到说晚安的时候呢！不要跟小丛雨开玩笑了啦……")
return
# 5:00 前收到的晚安命令算到前一天里
if time.hour < 5:
date -= timedelta(days=1)
# 存入入睡时间
if gid in data:
if date in data[gid]:
if uid in data[gid][date]:
# 如果已有入睡时间，刷新为新时间
if data[gid][date][uid][0] != -1:
data[gid][date][uid][0] = time
await good_night.finish("哼！不是已经说好了要睡觉了嘛！这次就原谅你了，赶快睡觉吧zzz")
return
data[gid][date][uid][0] = time
else:
data[gid][date][uid] = [time, -1]
data[gid][date][-1][0] += 1
else:
data[gid][date] = {-1: [1, 0], uid: [time, -1]}
else:
data[gid] = {date: {-1: [1, 0], uid: [time, -1]}}
save_to_file(data)
order = data[gid][date][-1][0]
await good_night.finish(
MessageSegment.at(uid) + f"晚安啦，你是本群第 {order} 个睡觉的人！记得睡觉要说到做到哦！")
async def safe_send(bot_id, send_type, type_id, message, at=False):
"""发送出现错误时, 尝试重新发送, 并捕获异常且不会中断运行"""
try:
bot = nonebot.get_bots()[str(bot_id)]
except KeyError:
logger.error(f"推送失败，Bot（{bot_id}）未连接")
return
if at and (await bot.get_group_at_all_remain(group_id=type_id)
)['can_at_all']:
message = MessageSegment.at('all') + message
try:
return await bot.call_api('send_'+send_type+'_msg', **{
'message': message,
'user_id' if send_type == 'private' else 'group_id': type_id
})
except ActionFailed as e:
url = "https://haruka-bot.sk415.icu/usage/faq.html#机器人不发消息也没反应"
logger.error(f"推送失败，账号可能被风控（{url}），错误信息：{e.info}")
except NetworkError as e:
logger.error(f"推送失败，请检查网络连接，错误信息：{e.msg}")
async def _arena_query(bot: Bot, event: Event, region: int, refresh=False):
refresh_quick_key_dic()
uid = event.user_id
isAt = True if event.detail_type == 'group' else False
# 处理输入数据
defen = str(event.message).strip()
defen = re.sub(r'[?？，,_]', '', defen)
defen, unknown = chara.roster.parse_team(defen)
if unknown:
_, name, score = chara.guess_id(unknown)
if score < 70 and not defen:
return # 忽略无关对话
msg = f'无法识别"{unknown}"' if score < 70 else f'无法识别"{unknown}" 您说的有{score}%可能是{name}'
return msg
if not defen:
return '查询请发送"怎么拆+防守队伍"，无需+号'
if len(defen) > 5:
return '编队不能多于5名角色'
if len(defen) < 5:
return '编队不能少于5名角色'
if len(defen) != len(set(defen)):
return '编队中含重复角色'
if any(chara.is_npc(i) for i in defen):
return '编队中含未实装角色'
if 1004 in defen:
return '\n⚠️您正在查询普通版炸弹人\n※万圣版可用万圣炸弹人/瓜炸等别称'
# 执行查询
# sv.logger.info('Doing query...')
res = await query(id_list=defen, user_id=uid, region=region, force=refresh)
# sv.logger.info('Got response!')
# 处理查询结果
if isinstance(res, str):
return f'查询出错，{res}'
if not len(res):
return '抱歉没有查询到解法\n※没有作业说明随便拆 发挥你的想象力～★\n作业上传请前往pcrdfans.com'
res = res[:min(6, len(res))] # 限制显示数量，截断结果
size = len(res)
target = Image.new('RGBA', (64 * 6, 64 * size + (size - 1) * 5),
(255, 255, 255, 255))
draw = ImageDraw.Draw(target)
ttffont = ImageFont.truetype(font_path, 16)
index = 0
for v in res:
atk = v['atk']
team_pic = chara.gen_team_pic(atk)
up = v['up'] + v['my_up']
down = v['down'] + v['my_down']
qkey = v['qkey']
pingjia = f'{qkey}\n\U0001F44D{up}\n\U0001F44E{down}'
draw.text((64 * 5, index * (64 + 5)),
pingjia,
font=ttffont,
fill='#000000')
target.paste(team_pic, (0, index * (64 + 5)), team_pic)
index += 1
target = optimize_pic(target)
img = helper.pic2b64(target)
# 拼接回复
atk_team = MessageSegment.image(img)
defen = [chara.fromid(x).name for x in defen]
defen = f"防守方【{' '.join(defen)}】"
at = str(MessageSegment.at(uid)) if isAt else event.sender['nickname']
msg = [defen, f'已为骑士{at}查询到以下进攻方案：', str(atk_team)]
msg.append('Support by pcrdfans_com')
return '\n'.join(msg)
async def _(bot: Bot, event: GroupMessageEvent, state: T_State):
state["at"] = MessageSegment.at(event.get_user_id())
state["test"] = "test"
# message: /template {at} hello {test}!
ft = event.message.template(event.message)
await template.send(ft)
async def update_rss(rss: Rss, mode='init'):
try:
connect = sqlite3.connect('./db/rss.db')
cursor = connect.cursor()
if (mode == 'init'):
results = cursor.execute(
'SELECT * FROM rss WHERE rss_url="{rss_url}"'.format(
rss_url=rss.url))
results = [result for result in results]
rss.id = results[0][0]
r = requests.get(rss.url)
r = feedparser.parse(r.text)
new_items = [
Item(rss_id=rss.id, title=item['title'], link=item['link'])
for item in r['entries']
]
# 与存储在数据库中的item进行比较，查看是否有更新
sql = 'SELECT * FROM items WHERE rss_id={rss_id}'.format(rss_id=rss.id)
results = cursor.execute(sql)
old_items = [
Item(rss_id=item[0], id=item[1], title=item[2], link=item[3])
for item in results
]
update_items = []
for new_item in new_items:
is_update = True
for old_item in old_items:
if (old_item.title == new_item.title
and old_item.link == new_item.link):
is_update = False
break
if (is_update):
update_items.append(new_item)
if (len(update_items) >= 1):
for item in update_items:
sql = 'INSERT INTO items (rss_id,title,link) VALUES({rss_id},"{title}","{link}");'.format(
rss_id=item.rss_id,
title=item.title.replace('"', '""'),
link=item.link)
cursor.execute(sql)
connect.commit()
if (mode == 'update'):
bots = get_bots()
bot = None
for id in bots.keys():
bot = bots[id]
subscribres = cursor.execute(
'SELECT * FROM subscribe WHERE rss_id={rss_id}'.format(
rss_id=rss.id))
for update in update_items:
for subscribre in subscribres:
reply = msg.at(user_id=subscribre[1])
reply = reply + '您所订阅的{rss_name}更新了\r\ntitle:{title}\r\nurl:{url}'.format(
rss_name=subscribre[5],
title=update.title,
url=update.link)
try:
await bot.send_group_msg(group_id=subscribre[2],
message=reply)
except Exception:
raise Exception('发送rss更新失败！')
except Exception as e:
logger.error('rss {name}更新失败!'.format(name=rss.name))
raise Exception(e.args[0])
finally:
cursor.close()
connect.close()
