def remove_wallet_inl(bch, wallet_id):
keyboard = InlineKeyboardMarkup(row_width=2)
list_buttons = [
InlineKeyboardButton(_('Нет'),
callback_data='{}_{}_address_info'.format(
bch, wallet_id)),
InlineKeyboardButton(_('Нет'),
callback_data='{}_{}_address_info'.format(
bch, wallet_id)),
InlineKeyboardButton(_('Нет'),
callback_data='{}_{}_address_info'.format(
bch, wallet_id)),
InlineKeyboardButton(_('Да, удалить'),
callback_data='{}_{}_remove_address'.format(
bch, wallet_id))
]
random.shuffle(list_buttons)
list_buttons.append(
InlineKeyboardButton(_('Назад'),
callback_data='{}_{}_address_info'.format(
bch, wallet_id)))
for btn in list_buttons:
keyboard.insert(btn)
return keyboard
async def warn_func(message: Message, chat, user, text, strings, filter_action=False):
chat_id = chat["chat_id"]
chat_title = chat["chat_title"]
by_id = BOT_ID if filter_action is True else message.from_user.id
user_id = user["user_id"] if filter_action is False else user
if user_id == BOT_ID:
await message.reply(strings["warn_sofi"])
return
if not filter_action:
if user_id == message.from_user.id:
await message.reply(strings["warn_self"])
return
if await is_user_admin(chat_id, user_id):
if not filter_action:
await message.reply(strings["warn_admin"])
return
reason = text
warn_id = str(
(
await db.warns.insert_one(
{
"user_id": user_id,
"chat_id": chat_id,
"reason": str(reason),
"by": by_id,
}
)
).inserted_id
)
admin = await get_user_link(by_id)
member = await get_user_link(user_id)
text = strings["warn"].format(admin=admin, user=member, chat_name=chat_title)
if reason:
text += strings["warn_rsn"].format(reason=reason)
warns_count = await db.warns.count_documents(
{"chat_id": chat_id, "user_id": user_id}
)
buttons = InlineKeyboardMarkup().add(
InlineKeyboardButton(
"тЪая╕П Remove warn", callback_data="remove_warn_{}".format(warn_id)
)
)
if await db.rules.find_one({"chat_id": chat_id}):
buttons.insert(
InlineKeyboardButton(
"ЁЯУЭ Rules", url=await get_start_link(f"btn_rules_{chat_id}")
)
)
if warn_limit := await db.warnlimit.find_one({"chat_id": chat_id}):
max_warn = int(warn_limit["num"])
async def select_lang_keyboard(message, strings):
markup = InlineKeyboardMarkup(row_width=2)
lang_info = await get_chat_lang_info(message.chat.id)
if message.chat.type == 'private':
text = strings['your_lang'].format(lang=lang_info['flag'] + " " +
lang_info['babel'].display_name)
text += strings['select_pm_lang']
# TODO: Connected chat lang info
else:
text = strings['chat_lang'].format(lang=lang_info['flag'] + " " +
lang_info['babel'].display_name)
text += strings['select_chat_lang']
for lang in LANGUAGES.values():
lang_info = lang['language_info']
markup.insert(
InlineKeyboardButton(
lang_info['flag'] + " " + lang_info['name'],
callback_data=select_lang_cb.new(lang=lang_info['code'])))
markup.add(
InlineKeyboardButton(strings['crowdin_btn'],
url='https://crowdin.com/project/sophiebot'))
await message.reply(text, reply_markup=markup)
async def select_lang_keyboard(message, strings, edit=False):
markup = InlineKeyboardMarkup(row_width=2)
task = message.reply if edit is False else message.edit_text
lang_info = await get_chat_lang_info(message.chat.id)
if message.chat.type == "private":
text = strings["your_lang"].format(lang=lang_info["flag"] + " " +
lang_info["babel"].display_name)
text += strings["select_pm_lang"]
# TODO: Connected chat lang info
else:
text = strings["chat_lang"].format(lang=lang_info["flag"] + " " +
lang_info["babel"].display_name)
text += strings["select_chat_lang"]
for lang in LANGUAGES.values():
lang_info = lang["language_info"]
markup.insert(
InlineKeyboardButton(
lang_info["flag"] + " " + lang_info["babel"].display_name,
callback_data=select_lang_cb.new(lang=lang_info["code"],
back_btn=edit is not False),
))
markup.add(
InlineKeyboardButton(strings["crowdin_btn"],
url="https://t.me/Daisysupport_official"))
if edit:
markup.add(
InlineKeyboardButton(strings["back"], callback_data="go_to_start"))
with suppress(MessageNotModified):
await task(text, reply_markup=markup)
async def select_lang_keyboard(message, strings, edit=False):
markup = InlineKeyboardMarkup(row_width=2)
task = message.reply if edit is False else message.edit_text
lang_info = await get_chat_lang_info(message.chat.id)
if message.chat.type == 'private':
text = strings['your_lang'].format(lang=lang_info['flag'] + " " +
lang_info['babel'].display_name)
text += strings['select_pm_lang']
# TODO: Connected chat lang info
else:
text = strings['chat_lang'].format(lang=lang_info['flag'] + " " +
lang_info['babel'].display_name)
text += strings['select_chat_lang']
for lang in LANGUAGES.values():
lang_info = lang['language_info']
markup.insert(
InlineKeyboardButton(
lang_info['flag'] + " " + lang_info['babel'].display_name,
callback_data=select_lang_cb.new(lang=lang_info['code'],
back_btn=edit is not False),
))
markup.add(
InlineKeyboardButton(strings['crowdin_btn'],
url='https://crowdin.com/project/hitsukix'))
if edit:
markup.add(
InlineKeyboardButton(strings['back'], callback_data='go_to_start'))
with suppress(MessageNotModified):
await task(text, reply_markup=markup)
def help_markup(modules):
markup = InlineKeyboardMarkup()
for module in modules:
markup.insert(
InlineKeyboardButton(module,
callback_data=helpmenu_cb.new(mod=module)))
return markup
async def set_access(user: User, data: dict):
bot_user = User.get(User.user_id == data['user_id'])
bot_user.access = data['mode']
keyboard = InlineKeyboardMarkup()
callback_data = {
'action': 'set_access',
'user_id': bot_user.user_id,
'mode': not bot_user.access
}
if bot_user.access:
btn_text = STRESS['access_granted_btn']
msg_text = STRESS['access_granted_msg']
else:
btn_text = STRESS['access_denied_btn']
msg_text = STRESS['access_denied_msg']
keyboard.insert(
InlineKeyboardButton(text=btn_text,
callback_data=json.dumps(callback_data)))
await bot.edit_message_reply_markup(ACCESS_CONTROL_CHANNEL_ID,
bot_user.access_msg_id,
reply_markup=keyboard)
if bot_user.access:
bot_user.state = 'default'
keyboard = ReplyKeyboardMarkup(resize_keyboard=True,
one_time_keyboard=True)
keyboard.add(KeyboardButton('Главное меню'))
else:
keyboard = ReplyKeyboardRemove()
bot_user.save()
await bot.send_message(bot_user.user_id, msg_text, reply_markup=keyboard)
def button_parser(chat_id, texts, pm=False, aio=False, row_width=None):
buttons = InlineKeyboardMarkup(row_width=row_width) if aio else []
pattern = r'\[(.+?)\]\((button|btn)(.+?)(:.+?|)(:same|)\)(\n|)'
raw_buttons = re.findall(pattern, texts)
text = re.sub(pattern, '', texts)
for raw_button in raw_buttons:
name = raw_button[0]
action = raw_button[2]
argument = raw_button[3][1:].lower() if raw_button[3] else ''
if action in BUTTONS:
cb = BUTTONS[action]
string = f'{cb}_{argument}_{chat_id}' if argument else f'{cb}_{chat_id}'
if aio:
start_btn = InlineKeyboardButton(
name, url=f'https://t.me/{BOT_USERNAME}?start=' + string)
cb_btn = InlineKeyboardButton(name, callback_data=string)
else:
start_btn = Button.url(
name, f'https://t.me/{BOT_USERNAME}?start=' + string)
cb_btn = Button.inline(name, string)
if cb.endswith('sm'):
btn = cb_btn if pm else start_btn
elif cb.endswith('cb'):
btn = cb_btn
elif cb.endswith('start'):
btn = start_btn
elif cb.startswith('url'):
btn = Button.url(name, argument)
elif action == 'url':
if argument[0] == '/' and argument[1] == '/':
argument = argument[2:]
btn = InlineKeyboardButton(
name, url=argument) if aio else Button.url(name, argument)
else:
# If btn not registred
btn = None
if argument:
text += f'\n[{name}].(btn{action}:{argument})'
else:
text += f'\n[{name}].(btn{action})'
continue
if aio:
buttons.insert(btn) if raw_button[4] else buttons.add(btn)
else:
if len(buttons) < 1 and raw_button[4]:
buttons.add(btn) if aio else buttons.append([btn])
else:
buttons[-1].append(btn) if raw_button[4] else buttons.append(
[btn])
if not aio and len(buttons) == 0:
buttons = None
if not text or text == ' ': # TODO: Sometimes we can return text == ' '
text = None
return text, buttons
async def warn_func(message: Message,
chat,
user,
text,
strings,
filter_action=False):
chat_id = chat['chat_id']
chat_title = chat['chat_title']
by_id = BOT_ID if filter_action is True else message.from_user.id
user_id = user['user_id'] if filter_action is False else user
if user_id == BOT_ID:
await message.reply(strings['warn_sofi'])
return
if not filter_action:
if user_id == message.from_user.id:
await message.reply(strings['warn_self'])
return
if await is_user_admin(chat_id, user_id):
if not filter_action:
await message.reply(strings['warn_admin'])
return
reason = text
warn_id = str((await db.warns.insert_one({
'user_id': user_id,
'chat_id': chat_id,
'reason': str(reason),
'by': by_id
})).inserted_id)
admin = await get_user_link(by_id)
member = await get_user_link(user_id)
text = strings['warn'].format(admin=admin,
user=member,
chat_name=chat_title)
if reason:
text += strings['warn_rsn'].format(reason=html.escape(reason))
warns_count = await db.warns.count_documents({
'chat_id': chat_id,
'user_id': user_id
})
buttons = InlineKeyboardMarkup().add(
InlineKeyboardButton("тЪая╕П Remove warn",
callback_data='remove_warn_{}'.format(warn_id)))
if await db.rules.find_one({'chat_id': chat_id}):
buttons.insert(
InlineKeyboardButton("ЁЯУЭ Rules",
url=await
get_start_link(f'btn_rules_{chat_id}')))
if warn_limit := await db.warnlimit.find_one({'chat_id': chat_id}):
max_warn = int(warn_limit['num'])
def get_help(chat_id):
text = "Select module to get help"
counter = 0
buttons = InlineKeyboardMarkup(row_width=2)
for module in HELP:
counter += 1
btn_name = get_string(module, "btn", chat_id, dir="HELPS")
buttons.insert(InlineKeyboardButton(btn_name, callback_data=help_page_cp.new(module=module)))
return text, buttons
async def categories_keyboard():
CURRENT_LEVEL = 0
markup = InlineKeyboardMarkup(row_width=2)
categories = await get_categories()
for category in categories:
button_text = f'{category.category_name}'
callback_data = make_callback_data(level=CURRENT_LEVEL + 1, category=category.category_code)
markup.insert(
InlineKeyboardButton(text=button_text, callback_data=callback_data)
)
return markup
async def get_mod_help_callback(query, callback_data=False, **kwargs):
chat_id = query.message.chat.id
message = query.message
module = callback_data['module']
lang = get_chat_lang(chat_id)
buttons = InlineKeyboardMarkup(row_width=2)
text = LANGUAGES[lang]["HELPS"][module]['text']
if 'buttons' in LANGUAGES[lang]["HELPS"][module]:
counter = 0
for btn in LANGUAGES[lang]["HELPS"][module]['buttons']:
counter += 1
btn_name = LANGUAGES[lang]["HELPS"][module]['buttons'][btn]
buttons.insert(InlineKeyboardButton(
btn_name, callback_data=help_btn_cp.new(module=module, btn=btn)))
buttons.add(InlineKeyboardButton("Back", callback_data='get_help'))
await message.edit_text(text, reply_markup=buttons)
async def warn_user(message, strings, status, chat_id, chat_title):
user, reason = await get_user_and_text(message)
if not user:
return
user_id = int(user['user_id'])
if user_id in WHITELISTED:
await message.reply(strings['usr_whitelist'])
return
if user_id in await get_chat_admins(chat_id):
await message.reply(strings['Admin_no_wrn'])
return
rndm = randomString(15)
mongodb.warns.insert_one({
'warn_id': rndm,
'user_id': user_id,
'group_id': chat_id,
'reason': str(reason)
})
admin_id = message.from_user.id
admin = mongodb.user_list.find_one({'user_id': admin_id})
admin_str = await user_link_html(admin['user_id'])
user_str = await user_link_html(user['user_id'])
text = strings['warn'].format(admin=admin_str,
user=user_str,
chat_name=chat_title)
if reason:
text += strings['warn_rsn'].format(reason=reason)
old = mongodb.warns.find({'user_id': user_id, 'group_id': chat_id})
h = 0
for suka in old:
h += 1
buttons = InlineKeyboardMarkup().add(
InlineKeyboardButton("тЪая╕П Remove warn",
callback_data='remove_warn_{}'.format(rndm)))
rules = mongodb.rules.find_one({"chat_id": chat_id})
if rules:
buttons.insert(
InlineKeyboardButton("ЁЯУЭ Rules",
callback_data='get_note_{}_{}'.format(
chat_id, rules['note'])))
if db_data := mongodb.warnlimit.find_one({'chat_id': chat_id}):
warn_limit = int(db_data['num'])
async def connect_chat_keyboard(message, strings, chat):
if chat['status'] != 'private':
text = strings['connected_chat'].format(chat_name=chat['chat_title'])
else:
text = ''
text += strings['select_chat_to_connect']
markup = InlineKeyboardMarkup(row_width=1)
if 'history' in (
connected := await db.connections_v2.find_one({'user_id': message.from_user.id},
{'history': {'$slice': -3}})):
for chat_id in reversed(connected['history']):
chat = await db.chat_list.find_one({'chat_id': chat_id})
markup.insert(InlineKeyboardButton(
chat['chat_title'],
callback_data=connect_to_chat_cb.new(chat_id=chat_id))
)
async def add_handler(message, chat, strings):
# filters doesn't support anon admins
if message.from_user.id == 1087968824:
return await message.reply(strings["anon_detected"])
# if not await check_admin_rights(message, chat_id, message.from_user.id, ["can_change_info"]):
# return await message.reply("You can't change info of this group")
handler = get_args_str(message)
if handler.startswith("re:"):
pattern = handler
random_text_str = "".join(random.choice(printable) for i in range(50))
try:
regex.match(pattern, random_text_str, timeout=0.2)
except TimeoutError:
await message.reply(strings["regex_too_slow"])
return
else:
handler = handler.lower()
text = strings["adding_filter"].format(
handler=handler, chat_name=chat["chat_title"]
)
buttons = InlineKeyboardMarkup(row_width=2)
for action in FILTERS_ACTIONS.items():
filter_id = action[0]
data = action[1]
buttons.insert(
InlineKeyboardButton(
await get_string(
chat["chat_id"], data["title"]["module"], data["title"]["string"]
),
callback_data=filter_action_cp.new(filter_id=filter_id),
)
)
buttons.add(InlineKeyboardButton(strings["cancel_btn"], callback_data="cancel"))
user_id = message.from_user.id
chat_id = chat["chat_id"]
redis.set(f"add_filter:{user_id}:{chat_id}", handler)
if handler is not None:
await message.reply(text, reply_markup=buttons)
def wallet_menu_inl(bch, wallet_id, is_subscribe):
keyboard = InlineKeyboardMarkup(row_width=2)
keyboard.add(
InlineKeyboardButton(_('Получать обновления: {status}'.format(
status='✅' if is_subscribe else '❌')),
callback_data='{}_{}_subscribe_to_updates'.format(
bch, wallet_id)))
keyboard.add(
InlineKeyboardButton(_('Указать имя'),
callback_data='{}_{}_set_address_name'.format(
bch, wallet_id)))
keyboard.insert(
InlineKeyboardButton(_('Сделать основным'),
callback_data='{}_{}_set_address_as_main'.format(
bch, wallet_id)))
keyboard.insert(
InlineKeyboardButton(_('Удалить кошелек'),
callback_data='{}_{}_try_remove_address'.format(
bch, wallet_id)))
keyboard.insert(
InlineKeyboardButton(_('Приватный ключ'),
callback_data='{}_{}_view_private_key'.format(
bch, wallet_id)))
keyboard.add(InlineKeyboardButton(_('Назад'), callback_data=f'{bch}_view'))
return keyboard
async def add_handler(message, chat, strings):
# filters doesn't support anon admins
if message.from_user.id == 1087968824:
return await message.reply(strings['anon_detected'])
handler = get_args_str(message)
if handler.startswith('re:'):
pattern = handler
random_text_str = ''.join(random.choice(printable) for i in range(50))
try:
regex.match(pattern, random_text_str, timeout=0.2)
except TimeoutError:
await message.reply(strings['regex_too_slow'])
return
else:
handler = handler.lower()
text = strings['adding_filter'].format(handler=handler,
chat_name=chat['chat_title'])
buttons = InlineKeyboardMarkup(row_width=2)
for action in FILTERS_ACTIONS.items():
filter_id = action[0]
data = action[1]
buttons.insert(
InlineKeyboardButton(
await get_string(chat['chat_id'], data['title']['module'],
data['title']['string']),
callback_data=filter_action_cp.new(filter_id=filter_id)))
buttons.add(
InlineKeyboardButton(strings['cancel_btn'], callback_data='cancel'))
user_id = message.from_user.id
chat_id = chat['chat_id']
redis.set(f'add_filter:{user_id}:{chat_id}', handler)
if handler is not None:
await message.reply(text, reply_markup=buttons)
async def subcategories_keyboard(category):
CURRENT_LEVEL = 1
markup = InlineKeyboardMarkup(row_width=2)
subcategories = await get_subcategories(category=category)
for subcategory in subcategories:
button_text = f"{subcategory.subcategory_name}"
callback_data = make_callback_data(
level=CURRENT_LEVEL + 1,
category=category,
subcategory=subcategory.subcategory_code,
)
markup.insert(
InlineKeyboardButton(text=button_text, callback_data=callback_data)
)
markup.row(
InlineKeyboardButton(
text="Back",
callback_data=make_callback_data(level=CURRENT_LEVEL - 1)
)
)
return markup
async def task(message: types.Message):
inline_button_add = InlineKeyboardButton('Добавить задачу 📋',
callback_data=task_callback.new(
0, 'add'))
inline_button_remove_all = InlineKeyboardButton(
'Удалить все 💥', callback_data=task_callback.new(0, 'remove_all'))
inline_task = InlineKeyboardMarkup().row(inline_button_add,
inline_button_remove_all)
await message.answer('<b> 💡 Твои задачи </b>',
parse_mode='HTML',
reply_markup=inline_task)
db_session = message.bot.get('db')
async with db_session() as session:
sql = select(Task).where(Task.student == message.from_user.id)
request = await session.execute(sql)
tasks = request.scalars()
k = 0
for task in tasks:
k += 1
inline_task = InlineKeyboardMarkup()
# Если задача готова то не надо кнопки
if task.status != 'Готово':
inline_task.insert(
InlineKeyboardButton('Выполнено✅',
callback_data=task_callback.new(
task.id, 'done')))
inline_task.insert(
InlineKeyboardButton('Удалить💥',
callback_data=task_callback.new(
task.id, 'delete')))
inline_task.insert(
InlineKeyboardButton('Изменить⚙',
callback_data=task_callback.new(
task.id, 'change')))
await message.answer(
f"<b> {time_lesson.emojiStatus[task.status]} {task.lesson} | {task.name} | {task.desc} \n Срок до {time_lesson.emojiToday[task.time.weekday()+1]} - {task.time.strftime('%d.%m.%y')} </b> \n ",
parse_mode='HTML',
reply_markup=inline_task)
if k == 0:
await message.answer("Пока что у тебя нету задач",
parse_mode='HTML')
chat_title = connected_data['chat_id']
text = strings['connected_chat:cmds'].format(
chat_name=chat_title,
# disconnect is builtin command, should not be shown
commands=", ".join(f"<code>/{cmd}</code>"
for cmd in connected_data['command']
if cmd != "disconnect"))
else:
text = ''
text += strings['select_chat_to_connect']
markup = InlineKeyboardMarkup(row_width=1)
for chat_id in reversed(connected_data['history'][-3:]):
chat = await db.chat_list.find_one({'chat_id': chat_id})
markup.insert(
InlineKeyboardButton(
chat['chat_title'],
callback_data=connect_to_chat_cb.new(chat_id=chat_id)))
await message.reply(text, reply_markup=markup)
# Callback for prev. function
@register(connect_to_chat_cb.filter(), f='cb', allow_kwargs=True)
async def connect_chat_keyboard_cb(message, callback_data=False, **kwargs):
chat_id = int(callback_data['chat_id'])
chat = await db.chat_list.find_one({'chat_id': chat_id})
await def_connect_chat(message.message,
message.from_user.id,
chat_id,
chat['chat_title'],
edit=True)
async def warn_user(message, strings, status, chat_id, chat_title):
user, reason = await aio_get_user(message)
if not user:
return
user_id = int(user['user_id'])
if user_id in WHITELISTED:
await message.reply(strings['usr_whitelist'])
return
if user_id in await get_chat_admins(chat_id):
await message.reply(strings['Admin_no_wrn'])
return
rndm = randomString(15)
mongodb.warns.insert_one({
'warn_id': rndm,
'user_id': user_id,
'group_id': chat_id,
'reason': str(reason)
})
admin_id = message.from_user.id
admin = mongodb.user_list.find_one({'user_id': admin_id})
admin_str = await user_link_html(admin['user_id'])
user_str = await user_link_html(user['user_id'])
text = strings['warn'].format(admin=admin_str,
user=user_str,
chat_name=chat_title)
if reason:
text += strings['warn_rsn'].format(reason=reason)
old = mongodb.warns.find({'user_id': user_id, 'group_id': chat_id})
h = 0
for suka in old:
h += 1
buttons = InlineKeyboardMarkup().add(
InlineKeyboardButton("тЪая╕П Remove warn",
callback_data='remove_warn_{}'.format(rndm)))
rules = mongodb.rules.find_one({"chat_id": chat_id})
if rules:
buttons.insert(
InlineKeyboardButton("ЁЯУЭ Rules",
callback_data='get_note_{}_{}'.format(
chat_id, rules['note'])))
warn_limit = mongodb.warnlimit.find_one({'chat_id': chat_id})
if not warn_limit:
warn_limit = 3
else:
warn_limit = int(warn_limit['num'])
if is_user_premium(user_id):
warn_limit += 1
if h >= warn_limit:
if await ban_user(message, user_id, chat_id, None) is False:
return
text += strings['warn_bun'].format(user=user_str)
mongodb.warns.delete_many({'user_id': user_id, 'group_id': chat_id})
else:
text += strings['warn_num'].format(curr_warns=h, max_warns=warn_limit)
await message.reply(text,
reply_markup=buttons,
disable_web_page_preview=True)
async def get_build_info(message, **args):
codename = message.text.split('@rSophieBot')[0][1:].lower()
device = mongodb.ofox_devices.find_one({'codename': codename})
if not device:
return
chat_id = message.chat.id
chat_type = 'stable'
files_dir = 'OrangeFox-Stable/'
text = ''
if chat_id in FOX_BETA_CHATS:
text = '<b>OrangeFox Recovery Beta</b>\n'
chat_type = 'beta'
files_dir = 'OrangeFox-Beta/'
if f'{chat_type}_build' not in device:
text = f'This device not support {chat_type} builds, check '
if chat_type == 'stable':
text += '<a href="https://t.me/joinchat/HNZTNkxOlyslccxryvKeeQ">OrangeFox Beta chat</a>'
else:
text += '<a href="https://t.me/OrangeFoxChat">OrangeFox Main chat</a>'
await message.reply(text)
return
last_build = device[chat_type + "_build"]
text += f"📱 <b>{device['fullname']}</b> (<code>{device['codename']}</code>)"
text += f'\n📄 Last {chat_type} build: <code>{last_build}</code>'
date_str = datetime.datetime.fromtimestamp(
device[f'{chat_type}_date']).strftime('%a %b %d %H:%M %Y')
text += f'\n📅 Date: <code>{date_str}</code>'
text += f"\n👨🔬 Maintainer: {device['maintainer']}"
if 'status' in device:
text += f", status: <code>{device['status']}</code>"
if f'{chat_type}_md5' in device:
text += f"\n✅ File MD5: <code>{device[chat_type + '_md5']}</code>"
if f'{chat_type}_build_bugs' in device:
text += f'\n🐞 Build Bugs:\n' + device[chat_type + '_build_bugs']
if f'{chat_type}_special_notes' in device:
text += f'\n📝 Build Notes:\n' + device[chat_type + '_special_notes']
if os.path.exists(FOX_FILES_LOCAL + files_dir + codename + '/' +
last_build[:-3] + 'txt'):
text += f"\n<a href=\"{FOX_DOMAIN + files_dir + codename + '/' + last_build[:-3] + 'txt'}\">🗒 View changelog and more info</a>"
buttons = InlineKeyboardMarkup().add(
InlineKeyboardButton("⬇️ Download this build",
url=FOX_DOMAIN + files_dir + codename + '/' +
last_build))
if f'{chat_type}_sf' in device and device[f'{chat_type}_sf'] is True:
print('owo')
buttons.add(
InlineKeyboardButton("🗄️ All builds", url=FOX_DOMAIN + files_dir))
sf_url = 'https://sourceforge.net/projects/orangefox/files/' + codename + '/' + last_build
buttons.insert(InlineKeyboardButton("☁️ Cloud", url=sf_url))
else:
buttons.insert(
InlineKeyboardButton("🗄️ All builds", url=FOX_DOMAIN + files_dir))
msg = await message.reply(text,
reply_markup=buttons,
disable_web_page_preview=True)
# Del prev msg code
old_msg = mongodb.old_fox_msgs.find_one({'chat_id': chat_id})
new = {
'chat_id': chat_id,
'last_msg': msg.message_id,
'last_user_msg': message.message_id
}
if not old_msg:
mongodb.old_fox_msgs.insert_one(new)
return
owo = []
if 'last_msg' in old_msg:
owo.append(old_msg['last_msg'])
if 'last_user_msg' in old_msg:
owo.append(old_msg['last_user_msg'])
try:
await tbot.delete_messages(chat_id, owo)
except Exception:
pass
mongodb.old_fox_msgs.update_one({'_id': old_msg['_id']}, {'$set': new},
upsert=True)
def button_parser(chat_id, texts, pm=False, aio=False, row_width=None):
buttons = InlineKeyboardMarkup(row_width=row_width) if aio else []
pattern = r"\[(.+?)\]\((button|btn|#)(.+?)(:.+?|)(:same|)\)(\n|)"
raw_buttons = re.findall(pattern, texts)
text = re.sub(pattern, "", texts)
btn = None
for raw_button in raw_buttons:
name = raw_button[0]
action = (raw_button[1]
if raw_button[1] not in ("button", "btn") else raw_button[2])
if raw_button[3]:
argument = raw_button[3][1:].lower().replace("`", "")
elif action in ("#"):
argument = raw_button[2]
print(raw_button[2])
else:
argument = ""
if action in BUTTONS.keys():
cb = BUTTONS[action]
string = f"{cb}_{argument}_{chat_id}" if argument else f"{cb}_{chat_id}"
if aio:
start_btn = InlineKeyboardButton(
name, url=f"https://t.me/{BOT_USERNAME}?start=" + string)
cb_btn = InlineKeyboardButton(name, callback_data=string)
else:
start_btn = Button.url(
name, f"https://t.me/{BOT_USERNAME}?start=" + string)
cb_btn = Button.inline(name, string)
if cb.endswith("sm"):
btn = cb_btn if pm else start_btn
elif cb.endswith("cb"):
btn = cb_btn
elif cb.endswith("start"):
btn = start_btn
elif cb.startswith("url"):
# Workaround to make URLs case-sensitive TODO: make better
argument = raw_button[3][1:].replace(
"`", "") if raw_button[3] else ""
btn = Button.url(name, argument)
elif cb.endswith("rules"):
btn = start_btn
elif action == "url":
argument = raw_button[3][1:].replace("`",
"") if raw_button[3] else ""
if argument[0] == "/" and argument[1] == "/":
argument = argument[2:]
btn = (InlineKeyboardButton(name, url=argument)
if aio else Button.url(name, argument))
else:
# If btn not registred
btn = None
if argument:
text += f"\n[{name}].(btn{action}:{argument})"
else:
text += f"\n[{name}].(btn{action})"
continue
if btn:
if aio:
buttons.insert(btn) if raw_button[4] else buttons.add(btn)
else:
if len(buttons) < 1 and raw_button[4]:
buttons.add(btn) if aio else buttons.append([btn])
else:
buttons[-1].append(
btn) if raw_button[4] else buttons.append([btn])
if not aio and len(buttons) == 0:
buttons = None
if not text or text.isspace(): # TODO: Sometimes we can return text == ' '
text = None
return text, buttons
async def report_error(event, telethon=False):
error = str(sys.exc_info()[1])
class_error = sys.exc_info()[0].__name__
if class_error == 'ChatWriteForbiddenError':
# This error mean bot is muted in chat
return
elif class_error == 'BadRequest' and error == 'Have no rights to send a message':
return
elif class_error == 'RetryAfter':
return
if telethon is True:
msg = event
chat_id = msg.chat_id
lib = 'Telethon'
else:
msg = event.message
chat_id = msg.chat.id
lib = 'Aiogram'
date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
logger.error("Error: " + date)
logger.error("Lib: " + lib)
if telethon is True:
logger.error(traceback.format_exc())
if DEBUG_MODE is True:
await msg.reply(error)
return
new = {
'error_class_name': class_error,
'error': error,
'date': datetime.datetime.now()
}
mongodb.errors.insert_one(new)
text = "<b>Sorry, I encountered a error!</b>\n"
text += f"If you wanna you can report it - just press the \"Report error\" button.\n"
text += "Till you press report button your data will be only here.\n"
text += "<a href=\"https://t.me/YanaBotGroup\">Sophie support chat</a>"
ftext = "Sophie error log file."
ftext += "\n______________________\n"
ftext += "\nDate: " + date
ftext += "\nLib: " + lib
ftext += "\nGroup ID: " + str(chat_id)
ftext += "\nSender ID: " + str(msg.from_user.id if lib ==
"Aiogram" else msg.from_id)
ftext += "\nText: " + str(msg.text or "")
ftext += "\n\nRaw update text:\n"
ftext += str(event)
ftext += "\n\nTraceback info:\n"
ftext += str(traceback.format_exc())
ftext += "\n\nFormatted update text:\n"
ftext += str(ujson.dumps(msg, indent=2))
command = "git log --pretty=format:\"%an: %s\" -5"
ftext += "\n\n\nLast 5 commits:\n"
ftext += await term(command)
buttons = InlineKeyboardMarkup(row_width=1).add(
InlineKeyboardButton(
"Delete message",
callback_data='get_delete_msg_{}_admin'.format(chat_id)))
if CONFIG['advanced']['errors_channel_enabled'] is True:
buttons.insert(
InlineKeyboardButton("Report error", callback_data='report_error'))
await bot.send_document(chat_id,
types.InputFile(io.StringIO(ftext),
filename="Error.txt"),
caption=text,
reply_to_message_id=msg.message_id
if lib == "Aiogram" else msg.message.id,
reply_markup=buttons)
return
