2022-08-27 16:17:01 +00:00
|
|
|
import asyncio
|
|
|
|
import os
|
2023-07-14 16:23:16 +00:00
|
|
|
import re
|
2023-12-07 02:59:44 +00:00
|
|
|
import shutil
|
2022-08-27 16:17:01 +00:00
|
|
|
import sys
|
|
|
|
from datetime import datetime, timedelta
|
|
|
|
|
|
|
|
import matplotlib.pyplot as plt
|
|
|
|
import numpy as np
|
|
|
|
import ujson as json
|
2023-09-03 08:50:12 +00:00
|
|
|
from dateutil.relativedelta import relativedelta
|
2022-08-27 16:17:01 +00:00
|
|
|
|
2023-07-05 15:14:43 +00:00
|
|
|
from config import Config, CFG
|
2023-12-10 14:07:32 +00:00
|
|
|
from core.builtins import Bot, PrivateAssets, Image, Plain, ExecutionLockList, Temp, MessageTaskManager
|
2023-03-04 08:51:56 +00:00
|
|
|
from core.component import module
|
2022-08-27 17:51:43 +00:00
|
|
|
from core.loader import ModulesManager
|
2023-12-10 14:07:32 +00:00
|
|
|
from core.logger import logger
|
2022-08-27 16:17:01 +00:00
|
|
|
from core.parser.message import remove_temp_ban
|
2023-12-07 06:58:09 +00:00
|
|
|
from core.scheduler import CronTrigger
|
2022-08-27 16:17:01 +00:00
|
|
|
from core.tos import pardon_user, warn_user
|
|
|
|
from core.utils.cache import random_cache_path
|
2023-09-01 11:45:26 +00:00
|
|
|
from core.utils.info import Info
|
2023-09-03 08:50:12 +00:00
|
|
|
from core.utils.storedata import get_stored_list, update_stored_list
|
|
|
|
from database import BotDBUtil
|
2022-08-27 16:17:01 +00:00
|
|
|
|
2023-12-09 04:09:49 +00:00
|
|
|
su = module('superuser', alias='su', required_superuser=True, base=True)
|
2022-08-27 16:17:01 +00:00
|
|
|
|
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@su.command('add <UserID>')
|
2023-11-19 13:44:48 +00:00
|
|
|
async def add_su(msg: Bot.MessageSession):
|
|
|
|
user = msg.parsed_msg['<UserID>']
|
|
|
|
if not user.startswith(f'{msg.target.sender_from}|'):
|
2023-11-27 15:13:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.superuser.invalid", target=msg.target.sender_from))
|
2022-08-27 16:17:01 +00:00
|
|
|
if user:
|
|
|
|
if BotDBUtil.SenderInfo(user).edit('isSuperUser', True):
|
2023-11-19 13:44:48 +00:00
|
|
|
await msg.finish(msg.locale.t("success"))
|
2022-08-27 16:17:01 +00:00
|
|
|
|
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@su.command('remove <UserID>')
|
2023-11-19 13:44:48 +00:00
|
|
|
async def del_su(msg: Bot.MessageSession):
|
|
|
|
user = msg.parsed_msg['<UserID>']
|
|
|
|
if not user.startswith(f'{msg.target.sender_from}|'):
|
2023-11-27 15:13:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.superuser.invalid", target=msg.target.sender_from))
|
2023-11-19 08:25:02 +00:00
|
|
|
if user == msg.target.sender_id:
|
2023-11-19 13:38:30 +00:00
|
|
|
confirm = await msg.wait_confirm(msg.locale.t("core.message.confirm"), append_instruction=False)
|
2023-11-19 08:25:02 +00:00
|
|
|
if not confirm:
|
2023-11-19 08:27:52 +00:00
|
|
|
return
|
2022-08-27 16:17:01 +00:00
|
|
|
if user:
|
|
|
|
if BotDBUtil.SenderInfo(user).edit('isSuperUser', False):
|
2023-11-19 13:44:48 +00:00
|
|
|
await msg.finish(msg.locale.t("success"))
|
2022-08-27 16:17:01 +00:00
|
|
|
|
|
|
|
|
2023-09-28 04:35:30 +00:00
|
|
|
ana = module('analytics', required_superuser=True, base=True)
|
2022-08-27 16:17:01 +00:00
|
|
|
|
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@ana.command()
|
2023-02-06 13:21:53 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2022-08-27 16:17:01 +00:00
|
|
|
if Config('enable_analytics'):
|
|
|
|
first_record = BotDBUtil.Analytics.get_first()
|
|
|
|
get_counts = BotDBUtil.Analytics.get_count()
|
2023-10-11 09:28:34 +00:00
|
|
|
|
2023-09-16 03:24:48 +00:00
|
|
|
new = datetime.now().replace(hour=0, minute=0, second=0) + timedelta(days=1)
|
|
|
|
old = datetime.now().replace(hour=0, minute=0, second=0)
|
2023-09-16 03:20:47 +00:00
|
|
|
get_counts_today = BotDBUtil.Analytics.get_count_by_times(new, old)
|
2023-10-11 09:28:34 +00:00
|
|
|
|
2023-12-10 14:50:07 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.analytics.counts", first_record=first_record.timestamp,
|
2023-09-16 03:20:47 +00:00
|
|
|
counts=get_counts, counts_today=get_counts_today))
|
2022-08-27 16:17:01 +00:00
|
|
|
else:
|
2023-09-15 18:34:55 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.analytics.disabled"))
|
2022-08-27 16:17:01 +00:00
|
|
|
|
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@ana.command('days [<name>]')
|
2023-02-06 13:21:53 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2022-08-27 16:17:01 +00:00
|
|
|
if Config('enable_analytics'):
|
|
|
|
first_record = BotDBUtil.Analytics.get_first()
|
|
|
|
module_ = None
|
|
|
|
if '<name>' in msg.parsed_msg:
|
|
|
|
module_ = msg.parsed_msg['<name>']
|
2023-06-04 09:26:23 +00:00
|
|
|
if module_ is None:
|
2023-12-10 14:50:07 +00:00
|
|
|
result = msg.locale.t("core.message.analytics.days.total", first_record=first_record.timestamp)
|
2023-06-04 09:26:23 +00:00
|
|
|
else:
|
2023-09-15 18:34:55 +00:00
|
|
|
result = msg.locale.t("core.message.analytics.days", module=module_,
|
2023-12-10 14:50:07 +00:00
|
|
|
first_record=first_record.timestamp)
|
2022-08-27 16:17:01 +00:00
|
|
|
data_ = {}
|
|
|
|
for d in range(30):
|
|
|
|
new = datetime.now().replace(hour=0, minute=0, second=0) + timedelta(days=1) - timedelta(days=30 - d - 1)
|
|
|
|
old = datetime.now().replace(hour=0, minute=0, second=0) + timedelta(days=1) - timedelta(days=30 - d)
|
|
|
|
get_ = BotDBUtil.Analytics.get_count_by_times(new, old, module_)
|
|
|
|
data_[old.day] = get_
|
|
|
|
data_x = []
|
|
|
|
data_y = []
|
|
|
|
for x in data_:
|
|
|
|
data_x.append(str(x))
|
|
|
|
data_y.append(data_[x])
|
|
|
|
plt.plot(data_x, data_y, "-o")
|
|
|
|
plt.plot(data_x[-1], data_y[-1], "-ro")
|
|
|
|
plt.xlabel('Days')
|
|
|
|
plt.ylabel('Counts')
|
|
|
|
plt.tick_params(axis='x', labelrotation=45, which='major', labelsize=10)
|
|
|
|
|
|
|
|
plt.gca().yaxis.get_major_locator().set_params(integer=True)
|
|
|
|
for xitem, yitem in np.nditer([data_x, data_y]):
|
|
|
|
plt.annotate(yitem, (xitem, yitem), textcoords="offset points", xytext=(0, 10), ha="center")
|
|
|
|
path = random_cache_path() + '.png'
|
|
|
|
plt.savefig(path)
|
|
|
|
plt.close()
|
2023-06-04 09:26:23 +00:00
|
|
|
await msg.finish([Plain(result), Image(path)])
|
2023-06-14 01:58:16 +00:00
|
|
|
|
2023-06-04 08:20:03 +00:00
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@ana.command('year [<name>]')
|
2023-06-04 08:20:03 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
|
|
|
if Config('enable_analytics'):
|
|
|
|
first_record = BotDBUtil.Analytics.get_first()
|
|
|
|
module_ = None
|
|
|
|
if '<name>' in msg.parsed_msg:
|
|
|
|
module_ = msg.parsed_msg['<name>']
|
2023-06-04 09:26:23 +00:00
|
|
|
if module_ is None:
|
2023-12-10 14:50:07 +00:00
|
|
|
result = msg.locale.t("core.message.analytics.year.total", first_record=first_record.timestamp)
|
2023-06-04 09:26:23 +00:00
|
|
|
else:
|
2023-09-15 18:34:55 +00:00
|
|
|
result = msg.locale.t("core.message.analytics.year", module=module_,
|
2023-12-10 14:50:07 +00:00
|
|
|
first_record=first_record.timestamp)
|
2023-06-04 08:20:03 +00:00
|
|
|
data_ = {}
|
|
|
|
for d in range(12):
|
2023-06-14 01:58:16 +00:00
|
|
|
new = datetime.now().replace(month=1, day=1, hour=0, minute=0, second=0) + \
|
|
|
|
relativedelta(years=1) - relativedelta(months=12 - d - 1)
|
|
|
|
old = datetime.now().replace(month=1, day=1, hour=0, minute=0, second=0) + \
|
|
|
|
relativedelta(years=1) - relativedelta(months=12 - d)
|
2023-06-04 08:20:03 +00:00
|
|
|
get_ = BotDBUtil.Analytics.get_count_by_times(new, old, module_)
|
|
|
|
data_[old.month] = get_
|
|
|
|
data_x = []
|
|
|
|
data_y = []
|
|
|
|
for x in data_:
|
|
|
|
data_x.append(str(x))
|
|
|
|
data_y.append(data_[x])
|
|
|
|
plt.plot(data_x, data_y, "-o")
|
|
|
|
plt.plot(data_x[-1], data_y[-1], "-ro")
|
|
|
|
plt.xlabel('Months')
|
|
|
|
plt.ylabel('Counts')
|
|
|
|
plt.tick_params(axis='x', labelrotation=45, which='major', labelsize=10)
|
|
|
|
|
|
|
|
plt.gca().yaxis.get_major_locator().set_params(integer=True)
|
|
|
|
for xitem, yitem in np.nditer([data_x, data_y]):
|
|
|
|
plt.annotate(yitem, (xitem, yitem), textcoords="offset points", xytext=(0, 10), ha="center")
|
|
|
|
path = random_cache_path() + '.png'
|
|
|
|
plt.savefig(path)
|
|
|
|
plt.close()
|
2023-06-04 09:26:23 +00:00
|
|
|
await msg.finish([Plain(result), Image(path)])
|
2023-06-04 08:20:03 +00:00
|
|
|
|
2022-08-27 16:17:01 +00:00
|
|
|
|
2023-12-09 04:09:49 +00:00
|
|
|
purge = module('purge', required_superuser=True, base=True)
|
2023-12-07 01:26:23 +00:00
|
|
|
|
2023-12-09 13:42:46 +00:00
|
|
|
|
2023-12-07 01:26:23 +00:00
|
|
|
@purge.command()
|
2023-12-07 06:40:33 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2023-12-07 01:26:23 +00:00
|
|
|
cache_path = os.path.abspath(Config('cache_path'))
|
|
|
|
if os.path.exists(cache_path):
|
2023-12-07 03:14:43 +00:00
|
|
|
if os.listdir(cache_path):
|
|
|
|
shutil.rmtree(cache_path)
|
|
|
|
os.mkdir(cache_path)
|
|
|
|
await msg.finish(msg.locale.t("core.message.purge.success"))
|
|
|
|
else:
|
|
|
|
await msg.finish(msg.locale.t("core.message.purge.empty"))
|
2023-12-07 01:26:23 +00:00
|
|
|
else:
|
|
|
|
os.mkdir(cache_path)
|
|
|
|
await msg.finish(msg.locale.t("core.message.purge.empty"))
|
|
|
|
|
2022-08-27 17:51:43 +00:00
|
|
|
|
2023-12-07 06:40:33 +00:00
|
|
|
@purge.schedule(CronTrigger.from_crontab('0 0 * * *'))
|
|
|
|
async def _():
|
|
|
|
cache_path = os.path.abspath(Config('cache_path'))
|
|
|
|
Logger.info('Start purging cache...')
|
|
|
|
if os.path.exists(cache_path):
|
|
|
|
shutil.rmtree(cache_path)
|
2023-12-07 12:35:07 +00:00
|
|
|
os.mkdir(cache_path)
|
2023-12-09 13:42:46 +00:00
|
|
|
|
2023-12-07 06:40:33 +00:00
|
|
|
|
2023-12-07 01:26:23 +00:00
|
|
|
set_ = module('set', required_superuser=True, base=True)
|
2022-08-27 17:51:43 +00:00
|
|
|
|
2023-12-09 13:42:46 +00:00
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@set_.command('modules <target_id> <modules> ...')
|
2023-02-06 13:21:53 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2023-09-01 14:38:32 +00:00
|
|
|
target = msg.parsed_msg['<target_id>']
|
|
|
|
if not target.startswith(f'{msg.target.target_from}|'):
|
2023-05-19 04:46:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.set.invalid"))
|
2022-08-27 17:51:43 +00:00
|
|
|
target_data = BotDBUtil.TargetInfo(target)
|
|
|
|
if target_data.query is None:
|
2023-11-19 13:38:30 +00:00
|
|
|
confirm = await msg.wait_confirm(msg.locale.t("core.message.set.confirm.init"), append_instruction=False)
|
2023-11-19 13:26:42 +00:00
|
|
|
if not confirm:
|
2022-08-27 17:51:43 +00:00
|
|
|
return
|
|
|
|
modules = [m for m in [msg.parsed_msg['<modules>']] + msg.parsed_msg.get('...', [])
|
2023-09-01 14:38:32 +00:00
|
|
|
if m in ModulesManager.return_modules_list(msg.target.target_from)]
|
2022-08-27 17:51:43 +00:00
|
|
|
target_data.enable(modules)
|
2023-05-19 04:46:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.set.module.success") + ", ".join(modules))
|
2022-08-27 17:51:43 +00:00
|
|
|
|
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@set_.command('option <target_id> <k> <v>')
|
2023-02-06 13:21:53 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2023-09-01 14:38:32 +00:00
|
|
|
target = msg.parsed_msg['<target_id>']
|
2022-08-27 17:51:43 +00:00
|
|
|
k = msg.parsed_msg['<k>']
|
|
|
|
v = msg.parsed_msg['<v>']
|
2023-09-01 14:38:32 +00:00
|
|
|
if not target.startswith(f'{msg.target.target_from}|'):
|
2023-05-19 04:46:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.set.invalid"))
|
2022-08-27 17:51:43 +00:00
|
|
|
target_data = BotDBUtil.TargetInfo(target)
|
|
|
|
if target_data.query is None:
|
2023-11-19 13:38:30 +00:00
|
|
|
confirm = await msg.wait_confirm(msg.locale.t("core.message.set.confirm.init"), append_instruction=False)
|
2023-11-19 13:26:42 +00:00
|
|
|
if not confirm:
|
2022-08-27 17:51:43 +00:00
|
|
|
return
|
|
|
|
if v.startswith(('[', '{')):
|
|
|
|
v = json.loads(v)
|
2023-02-22 08:29:03 +00:00
|
|
|
elif v.upper() == 'TRUE':
|
2022-08-27 17:51:43 +00:00
|
|
|
v = True
|
2023-02-22 08:29:03 +00:00
|
|
|
elif v.upper() == 'FALSE':
|
2022-08-27 17:51:43 +00:00
|
|
|
v = False
|
|
|
|
target_data.edit_option(k, v)
|
2023-06-13 05:24:49 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.set.help.option.success", k=k, v=v))
|
2022-08-27 17:51:43 +00:00
|
|
|
|
|
|
|
|
2023-12-09 04:09:49 +00:00
|
|
|
ae = module('abuse', alias='ae', required_superuser=True, base=True)
|
2022-08-27 16:17:01 +00:00
|
|
|
|
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@ae.command('check <user>')
|
2023-02-06 13:21:53 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2022-08-27 16:17:01 +00:00
|
|
|
user = msg.parsed_msg['<user>']
|
2023-09-01 14:38:32 +00:00
|
|
|
if not user.startswith(f'{msg.target.sender_from}|'):
|
2023-05-19 04:46:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.set.invalid"))
|
2022-08-27 16:17:01 +00:00
|
|
|
warns = BotDBUtil.SenderInfo(user).query.warns
|
2023-05-19 04:46:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.abuse.check.warns", user=user, warns=warns))
|
2022-08-27 16:17:01 +00:00
|
|
|
|
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@ae.command('warn <user> [<count>]')
|
2023-02-06 13:21:53 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2022-08-27 16:17:01 +00:00
|
|
|
count = int(msg.parsed_msg.get('<count>', 1))
|
|
|
|
user = msg.parsed_msg['<user>']
|
2023-09-01 14:38:32 +00:00
|
|
|
if not user.startswith(f'{msg.target.sender_from}|'):
|
2023-05-19 04:46:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.set.invalid"))
|
2022-08-27 16:17:01 +00:00
|
|
|
warn_count = await warn_user(user, count)
|
2023-05-19 04:46:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.abuse.warn.success", user=user, counts=count, warn_counts=warn_count))
|
2022-08-27 16:17:01 +00:00
|
|
|
|
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@ae.command('revoke <user> [<count>]')
|
2023-02-06 13:21:53 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2022-08-27 16:17:01 +00:00
|
|
|
count = 0 - int(msg.parsed_msg.get('<count>', 1))
|
|
|
|
user = msg.parsed_msg['<user>']
|
2023-09-01 14:38:32 +00:00
|
|
|
if not user.startswith(f'{msg.target.sender_from}|'):
|
2023-05-19 04:46:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.set.invalid"))
|
2022-08-27 16:17:01 +00:00
|
|
|
warn_count = await warn_user(user, count)
|
2023-05-19 04:46:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.abuse.revoke.success", user=user, counts=count, warn_counts=warn_count))
|
2022-08-27 16:17:01 +00:00
|
|
|
|
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@ae.command('clear <user>')
|
2023-02-06 13:21:53 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2022-08-27 16:17:01 +00:00
|
|
|
user = msg.parsed_msg['<user>']
|
2023-09-01 14:38:32 +00:00
|
|
|
if not user.startswith(f'{msg.target.sender_from}|'):
|
2023-05-19 04:46:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.set.invalid"))
|
2022-08-27 16:17:01 +00:00
|
|
|
await pardon_user(user)
|
2023-05-19 04:46:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.abuse.clear.success", user=user))
|
2022-08-27 16:17:01 +00:00
|
|
|
|
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@ae.command('untempban <user>')
|
2023-02-06 13:21:53 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2022-08-27 16:17:01 +00:00
|
|
|
user = msg.parsed_msg['<user>']
|
2023-09-01 14:38:32 +00:00
|
|
|
if not user.startswith(f'{msg.target.sender_from}|'):
|
2023-05-19 04:46:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.set.invalid"))
|
2022-08-27 16:17:01 +00:00
|
|
|
await remove_temp_ban(user)
|
2023-05-19 04:46:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.abuse.untempban.success", user=user))
|
2022-08-27 16:17:01 +00:00
|
|
|
|
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@ae.command('ban <user>')
|
2023-02-06 13:21:53 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2022-08-27 16:17:01 +00:00
|
|
|
user = msg.parsed_msg['<user>']
|
2023-09-01 14:38:32 +00:00
|
|
|
if not user.startswith(f'{msg.target.sender_from}|'):
|
2023-05-19 04:46:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.set.invalid"))
|
2022-08-27 16:17:01 +00:00
|
|
|
if BotDBUtil.SenderInfo(user).edit('isInBlockList', True):
|
2023-05-19 04:46:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.abuse.ban.success", user=user))
|
2022-08-27 16:17:01 +00:00
|
|
|
|
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@ae.command('unban <user>')
|
2023-02-06 13:21:53 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2022-08-27 16:17:01 +00:00
|
|
|
user = msg.parsed_msg['<user>']
|
2023-09-01 14:38:32 +00:00
|
|
|
if not user.startswith(f'{msg.target.sender_from}|'):
|
2023-05-19 04:46:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.set.invalid"))
|
2022-08-27 16:17:01 +00:00
|
|
|
if BotDBUtil.SenderInfo(user).edit('isInBlockList', False):
|
2023-05-19 04:46:29 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.abuse.unban.success", user=user))
|
2022-08-27 16:17:01 +00:00
|
|
|
|
|
|
|
|
2023-12-10 12:25:45 +00:00
|
|
|
upd = module('update', required_superuser=True, base=True)
|
|
|
|
|
|
|
|
|
|
|
|
def pull_repo():
|
|
|
|
return os.popen('git pull', 'r').read()[:-1]
|
|
|
|
|
|
|
|
|
|
|
|
def update_dependencies():
|
|
|
|
poetry_install = os.popen('poetry install').read()[:-1]
|
|
|
|
if poetry_install != '':
|
|
|
|
return poetry_install
|
|
|
|
pip_install = os.popen('pip install -r requirements.txt').read()[:-1]
|
|
|
|
if len(pip_install) > 500:
|
|
|
|
return '...' + pip_install[-500:]
|
|
|
|
return
|
|
|
|
|
|
|
|
|
|
|
|
@upd.command()
|
|
|
|
async def update_bot(msg: Bot.MessageSession):
|
|
|
|
confirm = await msg.wait_confirm(msg.locale.t("core.message.confirm"), append_instruction=False)
|
|
|
|
if confirm:
|
|
|
|
pull_repo_result = pull_repo()
|
|
|
|
if pull_repo_result != '':
|
|
|
|
await msg.send_message(pull_repo_result)
|
|
|
|
else:
|
|
|
|
await msg.send_message(msg.locale.t("core.message.update.failed"))
|
|
|
|
await msg.send_message(update_dependencies())
|
|
|
|
|
|
|
|
if Info.subprocess:
|
|
|
|
rst = module('restart', required_superuser=True, base=True)
|
|
|
|
|
|
|
|
def restart():
|
|
|
|
sys.exit(233)
|
|
|
|
|
|
|
|
def write_version_cache(msg: Bot.MessageSession):
|
|
|
|
update = os.path.abspath(PrivateAssets.path + '/cache_restart_author')
|
|
|
|
write_version = open(update, 'w')
|
|
|
|
write_version.write(json.dumps({'From': msg.target.target_from, 'ID': msg.target.target_id}))
|
|
|
|
write_version.close()
|
|
|
|
|
|
|
|
restart_time = []
|
|
|
|
|
|
|
|
async def wait_for_restart(msg: Bot.MessageSession):
|
|
|
|
get = ExecutionLockList.get()
|
|
|
|
if datetime.now().timestamp() - restart_time[0] < 60:
|
|
|
|
if len(get) != 0:
|
|
|
|
await msg.send_message(msg.locale.t("core.message.restart.wait", count=len(get)))
|
|
|
|
await asyncio.sleep(10)
|
|
|
|
return await wait_for_restart(msg)
|
|
|
|
else:
|
|
|
|
await msg.send_message(msg.locale.t("core.message.restart.restarting"))
|
|
|
|
get_wait_list = MessageTaskManager.get()
|
|
|
|
for x in get_wait_list:
|
|
|
|
for y in get_wait_list[x]:
|
|
|
|
for z in get_wait_list[x][y]:
|
|
|
|
if get_wait_list[x][y][z]['active']:
|
|
|
|
await z.send_message(z.locale.t("core.message.restart.prompt"))
|
|
|
|
|
|
|
|
else:
|
|
|
|
await msg.send_message(msg.locale.t("core.message.restart.timeout"))
|
|
|
|
|
|
|
|
@rst.command()
|
|
|
|
async def restart_bot(msg: Bot.MessageSession):
|
|
|
|
confirm = await msg.wait_confirm(msg.locale.t("core.message.confirm"), append_instruction=False)
|
|
|
|
if confirm:
|
|
|
|
restart_time.append(datetime.now().timestamp())
|
|
|
|
await wait_for_restart(msg)
|
|
|
|
write_version_cache(msg)
|
|
|
|
restart()
|
|
|
|
|
|
|
|
|
|
|
|
if Info.subprocess:
|
|
|
|
upds = module('update&restart', required_superuser=True, alias='u&r', base=True)
|
|
|
|
|
|
|
|
@upds.command()
|
|
|
|
async def update_and_restart_bot(msg: Bot.MessageSession):
|
|
|
|
confirm = await msg.wait_confirm(msg.locale.t("core.message.confirm"), append_instruction=False)
|
|
|
|
if confirm:
|
|
|
|
restart_time.append(datetime.now().timestamp())
|
|
|
|
await wait_for_restart(msg)
|
|
|
|
write_version_cache(msg)
|
|
|
|
pull_repo_result = pull_repo()
|
|
|
|
if pull_repo_result != '':
|
|
|
|
await msg.send_message(pull_repo_result)
|
|
|
|
await msg.send_message(update_dependencies())
|
|
|
|
else:
|
|
|
|
Logger.warn(f'Failed to get Git repository result.')
|
|
|
|
await msg.send_message(msg.locale.t("core.message.update.failed"))
|
|
|
|
restart()
|
|
|
|
|
|
|
|
|
2023-02-04 14:42:21 +00:00
|
|
|
if Bot.FetchTarget.name == 'QQ':
|
2023-12-09 04:09:49 +00:00
|
|
|
resume = module('resume', required_base_superuser=True)
|
2023-02-04 14:42:21 +00:00
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@resume.command()
|
2023-02-06 13:21:53 +00:00
|
|
|
async def resume_sending_group_message(msg: Bot.MessageSession):
|
2023-02-06 10:02:44 +00:00
|
|
|
Temp.data['is_group_message_blocked'] = False
|
2023-02-04 14:42:21 +00:00
|
|
|
if targets := Temp.data['waiting_for_send_group_message']:
|
2023-09-01 14:38:32 +00:00
|
|
|
await msg.send_message(msg.locale.t("core.message.resume.processing", counts=len(targets)))
|
2023-02-04 14:42:21 +00:00
|
|
|
for x in targets:
|
2023-06-14 01:58:16 +00:00
|
|
|
if x['i18n']:
|
2023-09-01 14:38:32 +00:00
|
|
|
await x['fetch'].send_direct_message(x['fetch'].parent.locale.t(x['message'], **x['kwargs']))
|
2023-06-14 01:58:16 +00:00
|
|
|
else:
|
2023-09-01 14:38:32 +00:00
|
|
|
await x['fetch'].send_direct_message(x['message'])
|
2023-02-04 14:42:21 +00:00
|
|
|
Temp.data['waiting_for_send_group_message'].remove(x)
|
2023-04-17 08:36:38 +00:00
|
|
|
await asyncio.sleep(30)
|
2023-12-07 13:09:55 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.resume.done"))
|
2023-02-04 14:42:21 +00:00
|
|
|
else:
|
2023-12-07 13:09:55 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.resume.nothing"))
|
2023-02-18 07:13:24 +00:00
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@resume.command('continue')
|
2023-02-06 13:21:53 +00:00
|
|
|
async def resume_sending_group_message(msg: Bot.MessageSession):
|
2023-07-17 13:04:27 +00:00
|
|
|
if not Temp.data['waiting_for_send_group_message']:
|
2023-07-17 13:08:01 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.resume.nothing"))
|
2023-07-20 13:40:27 +00:00
|
|
|
|
2023-02-06 13:21:53 +00:00
|
|
|
del Temp.data['waiting_for_send_group_message'][0]
|
|
|
|
Temp.data['is_group_message_blocked'] = False
|
|
|
|
if targets := Temp.data['waiting_for_send_group_message']:
|
2023-09-01 14:38:32 +00:00
|
|
|
await msg.send_message(msg.locale.t("core.message.resume.skip", counts=len(targets)))
|
2023-02-06 13:21:53 +00:00
|
|
|
for x in targets:
|
2023-08-02 15:59:24 +00:00
|
|
|
if x['i18n']:
|
2023-09-01 14:38:32 +00:00
|
|
|
await x['fetch'].send_direct_message(x['fetch'].parent.locale.t(x['message']))
|
2023-08-02 15:59:24 +00:00
|
|
|
else:
|
2023-09-01 14:38:32 +00:00
|
|
|
await x['fetch'].send_direct_message(x['message'])
|
2023-02-06 13:21:53 +00:00
|
|
|
Temp.data['waiting_for_send_group_message'].remove(x)
|
2023-04-17 08:36:38 +00:00
|
|
|
await asyncio.sleep(30)
|
2023-12-07 13:09:55 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.resume.done"))
|
2023-02-06 13:21:53 +00:00
|
|
|
else:
|
2023-12-07 13:09:55 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.resume.nothing"))
|
2023-02-04 14:42:21 +00:00
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@resume.command('clear')
|
2023-04-17 08:36:38 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2023-04-24 00:23:43 +00:00
|
|
|
Temp.data['is_group_message_blocked'] = False
|
2023-04-17 08:36:38 +00:00
|
|
|
Temp.data['waiting_for_send_group_message'] = []
|
2023-12-07 13:09:55 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.resume.clear"))
|
2023-04-17 08:36:38 +00:00
|
|
|
|
2023-12-09 04:09:49 +00:00
|
|
|
forward_msg = module('forward_msg', required_superuser=True, base=True)
|
2023-06-02 07:47:49 +00:00
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@forward_msg.command()
|
2023-06-02 07:47:49 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
|
|
|
alist = get_stored_list(Bot.FetchTarget, 'forward_msg')
|
|
|
|
if not alist:
|
|
|
|
alist = {'status': True}
|
|
|
|
alist['status'] = not alist['status']
|
|
|
|
update_stored_list(Bot.FetchTarget, 'forward_msg', alist)
|
|
|
|
if alist['status']:
|
2023-12-07 13:09:55 +00:00
|
|
|
await msg.finish(msg.locale.t('core.message.forward_msg.enable'))
|
2023-06-02 07:47:49 +00:00
|
|
|
else:
|
2023-12-07 13:09:55 +00:00
|
|
|
await msg.finish(msg.locale.t('core.message.forward_msg.disable'))
|
2023-06-02 07:47:49 +00:00
|
|
|
|
2023-12-09 04:09:49 +00:00
|
|
|
echo = module('echo', required_superuser=True, base=True)
|
2022-08-27 16:17:01 +00:00
|
|
|
|
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@echo.command('<display_msg>')
|
2023-02-06 13:21:53 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2022-08-27 16:17:01 +00:00
|
|
|
await msg.finish(msg.parsed_msg['<display_msg>'])
|
|
|
|
|
|
|
|
|
2023-12-09 04:09:49 +00:00
|
|
|
say = module('say', required_superuser=True, base=True)
|
2022-08-27 16:17:01 +00:00
|
|
|
|
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@say.command('<display_msg>')
|
2023-02-06 13:21:53 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2022-08-27 16:17:01 +00:00
|
|
|
await msg.finish(msg.parsed_msg['<display_msg>'], quote=False)
|
|
|
|
|
2023-12-09 04:09:49 +00:00
|
|
|
rse = module('raise', required_superuser=True, base=True)
|
2023-09-15 18:34:55 +00:00
|
|
|
|
2023-12-09 13:42:46 +00:00
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@rse.command()
|
2023-09-15 18:34:55 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2023-11-13 16:14:04 +00:00
|
|
|
e = msg.locale.t("core.message.raise")
|
|
|
|
raise Exception(e)
|
2023-09-15 18:34:55 +00:00
|
|
|
|
2022-08-27 16:17:01 +00:00
|
|
|
|
|
|
|
if Config('enable_eval'):
|
2023-12-09 04:09:49 +00:00
|
|
|
_eval = module('eval', required_superuser=True, base=True)
|
2022-08-27 16:17:01 +00:00
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@_eval.command('<display_msg>')
|
2023-02-06 13:21:53 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2022-08-27 16:17:01 +00:00
|
|
|
await msg.finish(str(eval(msg.parsed_msg['<display_msg>'], {'msg': msg})))
|
2023-07-05 15:14:43 +00:00
|
|
|
|
|
|
|
|
2023-12-09 04:09:49 +00:00
|
|
|
_config = module('config', required_superuser=True, alias='cfg', base=True)
|
|
|
|
|
2023-12-09 14:38:38 +00:00
|
|
|
|
2023-07-14 16:23:16 +00:00
|
|
|
def isfloat(num):
|
|
|
|
try:
|
|
|
|
float(num)
|
|
|
|
return True
|
|
|
|
except ValueError:
|
|
|
|
return False
|
|
|
|
|
2023-12-09 13:42:46 +00:00
|
|
|
|
2023-11-13 15:48:19 +00:00
|
|
|
def isint(num):
|
|
|
|
try:
|
|
|
|
int(num)
|
|
|
|
return True
|
|
|
|
except ValueError:
|
|
|
|
return False
|
|
|
|
|
2023-07-14 16:23:16 +00:00
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@_config.command('write <k> <v> [-s]')
|
2023-07-05 15:14:43 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2023-07-14 16:23:16 +00:00
|
|
|
value = msg.parsed_msg['<v>']
|
2023-07-14 16:42:45 +00:00
|
|
|
if value.lower() == 'true':
|
2023-07-14 16:23:16 +00:00
|
|
|
value = True
|
2023-07-14 16:42:45 +00:00
|
|
|
elif value.lower() == 'false':
|
2023-07-14 16:23:16 +00:00
|
|
|
value = False
|
2023-11-13 15:48:19 +00:00
|
|
|
elif isint(value):
|
2023-07-14 16:23:16 +00:00
|
|
|
value = int(value)
|
|
|
|
elif isfloat(value):
|
|
|
|
value = float(value)
|
2023-11-13 15:48:19 +00:00
|
|
|
elif re.match(r'^\[.*\]$', value):
|
2023-11-13 15:05:55 +00:00
|
|
|
try:
|
|
|
|
value = json.loads(value)
|
2023-12-09 13:42:46 +00:00
|
|
|
except BaseException:
|
2023-11-13 15:51:20 +00:00
|
|
|
await msg.finish(msg.locale.t("core.message.config.write.failed"))
|
2023-07-14 16:23:16 +00:00
|
|
|
|
|
|
|
CFG.write(msg.parsed_msg['<k>'], value, msg.parsed_msg['-s'])
|
2023-07-05 15:14:43 +00:00
|
|
|
await msg.finish(msg.locale.t("success"))
|
|
|
|
|
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@_config.command('delete <k>')
|
2023-07-05 15:14:43 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
|
|
|
if CFG.delete(msg.parsed_msg['<k>']):
|
|
|
|
await msg.finish(msg.locale.t("success"))
|
|
|
|
else:
|
|
|
|
await msg.finish(msg.locale.t("failed"))
|
2023-07-20 13:40:27 +00:00
|
|
|
|
|
|
|
|
2023-07-31 14:42:13 +00:00
|
|
|
if Config('openai_api_key'):
|
2023-12-09 04:09:49 +00:00
|
|
|
petal = module('petal', base=True, alias='petals')
|
2023-07-31 14:42:13 +00:00
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@petal.command()
|
2023-07-31 14:42:13 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
2023-08-02 17:48:48 +00:00
|
|
|
await msg.finish(msg.locale.t('core.message.petal.self', petal=msg.data.petal))
|
2023-08-03 16:18:47 +00:00
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@petal.command('[<target>] {{core.help.petal}}', required_superuser=True)
|
2023-08-02 17:48:48 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
|
|
|
group = msg.parsed_msg['<target>']
|
|
|
|
target = BotDBUtil.TargetInfo(group)
|
|
|
|
await msg.finish(msg.locale.t('core.message.petal', group=group, petal=target.petal))
|
2023-07-31 14:42:13 +00:00
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@petal.command('modify <petal> [<target>]', required_superuser=True)
|
2023-07-31 14:42:13 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
|
|
|
petal = msg.parsed_msg['<petal>']
|
|
|
|
if '<target>' in msg.parsed_msg:
|
2023-08-02 12:00:55 +00:00
|
|
|
group = msg.parsed_msg['<target>']
|
|
|
|
target = BotDBUtil.TargetInfo(group)
|
2023-08-02 14:45:44 +00:00
|
|
|
target.modify_petal(int(petal))
|
2023-09-03 08:50:12 +00:00
|
|
|
await msg.finish(
|
|
|
|
msg.locale.t('core.message.petal.modify', group=group, add_petal=petal, petal=target.petal))
|
2023-07-31 14:42:13 +00:00
|
|
|
else:
|
|
|
|
target = msg.data
|
2023-08-02 14:45:44 +00:00
|
|
|
target.modify_petal(int(petal))
|
2023-08-02 15:00:29 +00:00
|
|
|
await msg.finish(msg.locale.t('core.message.petal.modify.self', add_petal=petal, petal=target.petal))
|
2023-10-11 09:28:34 +00:00
|
|
|
|
2023-10-20 19:26:36 +00:00
|
|
|
if Bot.client_name == 'QQ':
|
2023-10-11 09:28:34 +00:00
|
|
|
post_whitelist = module('post_whitelist', required_superuser=True, base=True)
|
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@post_whitelist.command('<group_id>')
|
2023-10-11 09:28:34 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
|
|
|
target_data = BotDBUtil.TargetInfo(msg.parsed_msg['<group_id>'])
|
|
|
|
k = 'in_post_whitelist'
|
|
|
|
v = not target_data.options.get(k, False)
|
|
|
|
target_data.edit_option(k, v)
|
|
|
|
await msg.finish(msg.locale.t("core.message.set.help.option.success", k=k, v=v))
|
2023-11-07 07:07:53 +00:00
|
|
|
|
2023-12-09 04:09:49 +00:00
|
|
|
lagrange = module('lagrange', required_superuser=True, base=True)
|
2023-11-07 07:07:53 +00:00
|
|
|
|
2023-12-06 17:55:11 +00:00
|
|
|
@lagrange.command()
|
2023-11-07 07:07:53 +00:00
|
|
|
async def _(msg: Bot.MessageSession):
|
|
|
|
await msg.finish(f'Keepalive: {str(Temp.data.get("lagrange_keepalive", "None"))}\n'
|
2023-11-07 07:09:34 +00:00
|
|
|
f'Status: {str(Temp.data.get("lagrange_status", "None"))}\n'
|
2023-11-07 07:07:53 +00:00
|
|
|
f'Groups: {str(Temp.data.get("lagrange_available_groups", "None"))}')
|