async def on_done_m(c: AndroidRepo, m: Message):
query = m.text.split()
command = query[0]
reply = m.reply_to_message
request = await get_request_by_user_id(message_id=reply.id)
if len(request) > 0:
request = request[0]
user_id = request.user
request_id = request.request_id
staff_msg = (
f"<code>{m.text[len(command)+1:]}</code>" if len(query) > 1 else "None"
)
doc = KanTeXDocument(
Section(
"Request done",
KeyValueItem(Bold("ID"), Code(request_id)),
KeyValueItem(Bold("Staff message"), Code(staff_msg)),
KeyValueItem(Bold("Request"), Code(request.request)),
),
Section(
"Note",
Italic("Don't be surprised, it will disappear from your request list."),
),
)
try:
await c.send_message(chat_id=user_id, text=doc)
except UserIsBlocked:
pass
await request.delete()
await m.reply_text("The request was successfully done.")
async def on_myrequests_m(c: AndroidRepo, m: Message):
user = m.from_user
requests = await get_request_by_user_id(user_id=user.id)
if requests:
doc = KanTeXDocument(
KeyValueItem(Bold("Ignored"), Code(bool(requests[0]["ignore"]))),
)
sec = Section("Requests")
for request in requests:
sec.append(
KeyValueItem(Bold(request["request_id"]), Code(request["request"]))
)
doc.append(sec)
doc.append(
Item("Use <code>/cancelrequest <id></code> to cancel a request.")
)
return await m.reply_text(doc)
return await m.reply_text("You haven't sent any request yet.")
async def bot_info(c: Korone, m: Message):
doc = Section(
"PyKorone Bot",
KeyValueItem(Bold("Source"), korone.__source__),
KeyValueItem(Bold("Korone"),
f"{korone.__version__} ({c.version_code})"),
KeyValueItem(Bold("Pyrogram"), pyrogram.__version__),
KeyValueItem(Bold("Python"), platform.python_version()),
)
await m.reply_text(doc, disable_web_page_preview=True)
async def on_info_u(c: Client, m: Message, user: User):
doc = KanTeXDocument(
Section(
user.first_name,
SubSection('General', KeyValueItem('id', Code(user.id)),
KeyValueItem('first_name', Code(user.first_name)),
KeyValueItem('last_name', Code(user.last_name)),
KeyValueItem('username', Code(user.username)))))
# TODO: add mention
await m.reply_text(doc)
async def on_deleted_m(c: AndroidRepo, messages: List[Message]):
for m in messages:
request = await get_request_by_message_id(message_id=m.id)
if request:
user_id = request[0]["user"]
request_id = request[0]["request_id"]
doc = KanTeXDocument(
Section(
"Request canceled",
KeyValueItem(Bold("ID"), Code(request_id)),
KeyValueItem(Bold("Request"), Code(request[0]["request"])),
)
)
await c.send_message(chat_id=user_id, text=doc)
await delete_request(user_id=user_id, request_id=request_id)
async def on_reply_m(c: AndroidRepo, m: Message):
answer = m.matches[0]["answer"]
reply = m.reply_to_message
request = await get_request_by_message_id(message_id=reply.id)
if request:
user_id = request[0]["user"]
request_id = request[0]["request_id"]
doc = KanTeXDocument(
Section(
"Answer to your request",
KeyValueItem(Bold("ID"), Code(request_id)),
KeyValueItem(Bold("Answer"), Code(answer)),
)
)
try:
await c.send_message(chat_id=user_id, text=doc)
except UserIsBlocked:
await m.reply_text("The user has blocked the bot!")
return
else:
m.continue_propagation()
async def on_info_m(c: AndroidRepo, m: Message):
magisk_modules = await get_all_modules()
source_url = "git.io/JtVsY"
doc = KanTeXDocument(
Section(
"AndroidRepo Bot",
SubSection(
"General",
KeyValueItem(Bold("Bot"), androidrepo.__version__),
KeyValueItem(Bold("KanTeX"), kantex.__version__),
KeyValueItem(Bold("Python"), platform.python_version()),
KeyValueItem(Bold("Pyrogram"), pyrogram.__version__),
KeyValueItem(Bold("Source"), source_url),
KeyValueItem(Bold("System"), c.system_version),
),
SubSection(
"Magisk", KeyValueItem(Bold("Modules"), Code(len(magisk_modules)))
),
)
)
await m.reply_text(doc, disable_web_page_preview=True)
async def system_info(c: Korone, m: Message):
uname = platform.uname()
# RAM usage
vm = psutil.virtual_memory()
vm_used = humanize.naturalsize(vm.used, binary=True)
vm_total = humanize.naturalsize(vm.total, binary=True)
# Swap usage
sm = psutil.swap_memory()
sm_used = humanize.naturalsize(sm.used, binary=True)
sm_total = humanize.naturalsize(sm.total, binary=True)
# CPU
cpu_freq = psutil.cpu_freq().current
if cpu_freq >= 1000:
cpu_freq = f"{round(cpu_freq / 1000, 2)}GHz"
else:
cpu_freq = f"{round(cpu_freq, 2)}MHz"
cpu_usage = (f"{psutil.cpu_percent(interval=1)}% "
f"({psutil.cpu_count()}) "
f"{cpu_freq}")
# Uptime
time_now = datetime.now().replace(tzinfo=timezone.utc)
uptime = time_now - c.start_time
doc = Section(
"PyKorone System",
KeyValueItem(Bold("OS"), Code(uname.system)),
KeyValueItem(Bold("Node"), Code(uname.node)),
KeyValueItem(Bold("Kernel"), Code(uname.release)),
KeyValueItem(Bold("Arch"), Code(uname.machine)),
KeyValueItem(Bold("CPU"), Code(cpu_usage)),
KeyValueItem(Bold("RAM"), Code(f"{vm_used}/{vm_total}")),
KeyValueItem(Bold("Swap"), Code(f"{sm_used}/{sm_total}")),
KeyValueItem(Bold("Uptime"), Code(humanize.precisedelta(uptime))),
)
await m.reply_text(doc, disable_web_page_preview=True)
async def on_request_m(c: AndroidRepo, m: Message):
if m.chat.type in (enums.ChatType.GROUP, enums.ChatType.SUPERGROUP):
keyboard = [
[
(
"Go to PM!",
f"http://t.me/{c.me.username}?start",
"url",
)
]
]
sent = await m.reply_text(
"Please use this command in private.",
reply_markup=c.ikb(keyboard),
)
await asyncio.sleep(5)
with suppress(BadRequest):
await sent.delete()
await m.delete()
return
user = m.from_user
requests = await get_request_by_user_id(user_id=user.id)
last_request = None
last_request_time = 0
if requests:
last_request = requests[-1]
last_request_time = last_request["time"]
now_time = time.time()
if user.id not in SUDO_USERS:
now = datetime.datetime.fromtimestamp(now_time)
if last_request_time > 0:
last = datetime.datetime.fromtimestamp(last_request_time)
if last_request["attempts"] > 3:
if bool(last_request["ignore"]):
return
await update_request(Ignore=1)
await c.send_log_message(
STAFF_ID,
f"{user.mention} was spamming requests and has been ignored.",
)
return await m.reply_text(
"You have spammed too many requests, so you will be ignored."
)
if (now - last).seconds < (3 * 60):
last_request.update_from_dict({"attempts": (last_request.attempts) + 1})
await last_request.save()
await c.send_log_message(
STAFF_ID, f"{user.mention} is spamming requests."
)
return await m.reply_text(
"You cannot send multiple requests one after the other, wait 3 minutes."
)
if requests is not None and len(requests) > 15:
return await m.reply_text("You have reached the requests limit.")
request = m.text[len(m.text.split()[0]) + 1 :]
doc = KanTeXDocument(
Section(
"New request",
KeyValueItem(Bold("From"), (user.mention)),
KeyValueItem(Bold("Request"), Code(request)),
)
)
sent = await c.send_log_message(STAFF_ID, doc)
if sent:
await create_request(
user_id=user.id,
time=now_time,
ignore=0,
request=request,
attempts=0,
request_id=(last_request["request_id"] if last_request else 0) + 1,
message_id=sent.id,
)
await m.reply_text("Your request was successfully sent!")
else:
await m.reply_text("There was a problem submitting your request.")
async def inline_sw(c: Korone, q: InlineQuery):
query = q.query.split()
if len(query) != 0 and query[0] == "sw":
args = " ".join(query[1:])
try:
user = await c.get_users(args) if args else q.from_user
except BadRequest as e:
await q.answer(
[
InlineQueryResultArticle(
title="Erro!",
description="Clique aqui para ver o erro.",
input_message_content=InputTextMessageContent(
f"<b>Erro:</b> <code>{e}</code>"),
)
],
cache_time=0,
)
return
r = await http.get(
f"https://api.spamwat.ch/banlist/{int(user.id)}",
headers={"Authorization": f"Bearer {SW_API}"},
)
spamwatch = Section(
f"{user.mention(html.escape(user.first_name), style='html')}", )
sw_ban = r.json()
if r.status_code == 200:
ban_message = sw_ban["message"]
if ban_message:
ban_message = (
f'{ban_message[:128]}{"[...]" if len(ban_message) > 128 else ""}'
)
spamwatch.extend([
SubSection(
"SpamWatch",
KeyValueItem(Bold("reason"), Code(sw_ban["reason"])),
KeyValueItem(
Bold("date"),
Code(datetime.fromtimestamp(sw_ban["date"])),
),
KeyValueItem(Bold("timestamp"), Code(sw_ban["date"])),
KeyValueItem(Bold("admin"), Code(sw_ban["admin"])),
KeyValueItem(Bold("message"), Code(ban_message)),
),
])
await q.answer(
[
InlineQueryResultArticle(
title=
f"Sobre {html.escape(user.first_name)} - SpamWatch",
description=
"Veja se o usuário está banido no SpamWatch.",
input_message_content=InputTextMessageContent(
spamwatch),
)
],
cache_time=0,
)
elif r.status_code == 404:
spamwatch.extend([
SubSection(
"SpamWatch",
KeyValueItem(Bold("banned"), Code("False")),
),
])
await q.answer(
[
InlineQueryResultArticle(
title=
f"Sobre {html.escape(user.first_name)} - SpamWatch",
description=
"Veja se o usuário está banido no SpamWatch.",
input_message_content=InputTextMessageContent(
spamwatch),
)
],
cache_time=0,
)