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 is_user_admin(chat_id, user_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 build_process_info(message, state, edit=True):
text = '<b>Build info</b>'
async with state.proxy() as data:
text += f"\nFile name: <code>{data['file_name']}</code>"
text += f"\nFile size: <code>{data['file_size']}</code>"
text += f"\nFile MD5: <code>{data['file_md5']}</code>"
text += f"\nFile SHA256: <code>{data['file_sha256']}</code>"
text += "\n"
text += f"\nDevice codename: <code>{data['device_codename']}</code>"
text += f"\nBuild type: <code>{data['build_type']}</code>"
text += f"\nBuild version: <code>{data['build_ver']}</code>"
if 'special_notes' not in data:
text += "\nBuild notes: Nothing"
else:
text += "\nBuild notes:\n" + data['special_notes']
if 'build_bugs' not in data:
text += "\nBuild bugs: Nothing"
else:
text += "\nBuild bugs:\n" + data['build_bugs']
text += "\nBuild changelog:\n" + data['changelog_text']
buttons = InlineKeyboardMarkup(row_width=2).add(
InlineKeyboardButton("📝 Change changelog", callback_data='fox_changelog_change')
)
if 'build_bugs' not in data:
buttons.add(InlineKeyboardButton("🐞 Add build bugs", callback_data='fox_add_build_bugs'))
else:
buttons.add(InlineKeyboardButton("🐞 Edit build bugs", callback_data='fox_add_build_bugs'))
if 'special_notes' not in data:
buttons.add(InlineKeyboardButton("✏️ Add build notes", callback_data='fox_add_build_notes'))
else:
buttons.add(
InlineKeyboardButton("✏️ Edit build notes", callback_data='fox_add_build_notes'),
InlineKeyboardButton("❌ Delete build notes", callback_data='fox_del_build_notes')
)
buttons.add(
InlineKeyboardButton("❌ Exit", callback_data='cancel'),
InlineKeyboardButton("🆗 Release it", callback_data='fox_release_build')
)
if edit is True:
await message.edit_text(text, reply_markup=buttons)
else:
await message.reply(text, reply_markup=buttons)
async def send_captcha(message, state, strings):
img, num = generate_captcha()
async with state.proxy() as data:
data['captcha_num'] = num
text = strings['ws_captcha_text'].format(
user=await get_user_link(message.from_user.id))
buttons = InlineKeyboardMarkup().add(
InlineKeyboardButton(strings['regen_captcha_btn'],
callback_data='regen_captcha'))
verify_msg_id = (await
message.answer_photo(img,
caption=text,
reply_markup=buttons)).message_id
async with state.proxy() as data:
data['verify_msg_id'] = verify_msg_id
async def add_handler(message, chat, strings):
handler = get_args_str(message).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.add(InlineKeyboardButton(
await get_string(chat['chat_id'], data['title']['module'], data['title']['string']),
callback_data=filter_action_cp.new(filter_id=filter_id)
))
user_id = message.from_user.id
chat_id = chat['chat_id']
redis.set(f'add_filter:{user_id}:{chat_id}', handler)
await message.reply(text, reply_markup=buttons)
async def get_notes_list_cmd(message, chat, strings):
if (
await db.privatenotes.find_one({"chat_id": chat["chat_id"]})
and message.chat.id == chat["chat_id"]
): # Workaround to avoid sending PN to connected PM
text = strings["notes_in_private"]
if not (keyword := message.get_args()):
keyword = None
button = InlineKeyboardMarkup().add(
InlineKeyboardButton(
text="Click here",
url=await get_start_link(f"notes_{chat['chat_id']}_{keyword}"),
)
)
return await message.reply(
text, reply_markup=button, disable_web_page_preview=True
)
def create_inline_keyboard(day):
inline_keyboard = InlineKeyboardMarkup()
btns = []
days_ukr = ['пн', 'вт', 'ср', 'чт', 'пт']
days_query = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday']
for i in range(5):
if i == day:
this_button = InlineKeyboardButton('➡️ ' + days_ukr[i], callback_data=days_query[i])
else:
this_button = InlineKeyboardButton(days_ukr[i], callback_data=days_query[i])
btns.append(this_button)
inline_keyboard.row(*btns)
inline_keyboard.add(InlineKeyboardButton('♻️ Змінити тиждень', callback_data='refresh'))
return inline_keyboard
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))
)
def get_start(chat_id):
strings = get_strings(chat_id, module='pm_menu')
text = strings["start_hi"]
buttons = InlineKeyboardMarkup()
buttons.add(
InlineKeyboardButton(strings["btn_help"], callback_data='get_help'))
buttons.add(
InlineKeyboardButton(strings["btn_lang"], callback_data='set_lang'))
buttons.add(
InlineKeyboardButton(strings["btn_chat"],
url='https://t.me/YanaBotGrou'),
InlineKeyboardButton(strings["btn_channel"],
url='https://t.me/SophieNEWS'),
)
return text, buttons
async def select_journal_year(user: User, data: dict):
keyboard = InlineKeyboardMarkup(row_width=2)
journal = Journal.get(Journal.id == data['journal_id'])
for journal_issue in (JournalIssue.select(JournalIssue.year).where(
JournalIssue.journal == journal).distinct().order_by(
JournalIssue.year.desc())):
callback_data = {
'action': 'select_issue',
'journal_id': data['journal_id'],
'year': journal_issue.year
}
n = len(json.dumps(callback_data))
keyboard.add(
InlineKeyboardButton(text=journal_issue.year,
callback_data=json.dumps(callback_data)))
await bot.send_message(user.user_id,
'Выберите год:',
reply_markup=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"])
# 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)
async def del_fed_cmd(message, fed, strings):
fed_name = html.escape(fed["fed_name"], False)
fed_id = fed["fed_id"]
fed_owner = fed["creator"]
buttons = InlineKeyboardMarkup()
buttons.add(
InlineKeyboardButton(
text=strings["delfed_btn_yes"],
callback_data=delfed_cb.new(fed_id=fed_id, creator_id=fed_owner),
)
)
buttons.add(
InlineKeyboardButton(
text=strings["delfed_btn_no"], callback_data=f"cancel_{fed_owner}"
)
)
await message.reply(strings["delfed"] % fed_name, reply_markup=buttons)
async def clear_all_notes(message, chat, strings):
# Ensure notes count
if not await db.notes.find_one({"chat_id": chat["chat_id"]}):
await message.reply(
strings["notelist_no_notes"].format(chat_title=chat["chat_title"])
)
return
text = strings["clear_all_text"].format(chat_name=chat["chat_title"])
buttons = InlineKeyboardMarkup()
buttons.add(
InlineKeyboardButton(
strings["clearall_btn_yes"], callback_data="clean_all_notes_cb"
)
)
buttons.add(
InlineKeyboardButton(strings["clearall_btn_no"], callback_data="cancel")
)
await message.reply(text, reply_markup=buttons)
async def get_start_func(message, strings, edit=False):
msg = message.message if hasattr(message, 'message') else message
task = msg.edit_text if edit else msg.reply
buttons = InlineKeyboardMarkup()
buttons.add(
InlineKeyboardButton(strings['btn_help'], callback_data='get_help'),
InlineKeyboardButton(strings['btn_lang'], callback_data='lang_btn'))
buttons.add(
InlineKeyboardButton(strings['btn_channel'],
url='https://t.me/utahupdates'),
InlineKeyboardButton(strings['btn_group_help'],
url='https://t.me/botunionsupport'))
buttons.add(
InlineKeyboardButton(
strings['btn_add'],
url=f'https://telegram.me/{BOT_USERNAME}?startgroup=true'))
# Handle error when user click the button 2 or more times simultaneously
with suppress(MessageNotModified):
await task(strings['start_hi'], reply_markup=buttons)
async def warn(message, chat, user, text, strings):
chat_id = chat['chat_id']
chat_title = chat['chat_title']
by_id = message.from_user.id
user_id = user['user_id']
if user_id == BOT_ID:
await message.reply(strings['warn_sofi'])
return
elif user_id == message.from_user.id:
await message.reply(strings['warn_self'])
return
elif await is_user_admin(chat_id, user_id):
await message.reply(strings['warn_admin'])
return
reason = text
warn_id = str((await db.warns_v2.insert_one({
'user_id': user_id,
'chat_id': chat_id,
'reason': str(reason),
'by': by_id
})).inserted_id)
admin = await get_user_link(message.from_user.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_v2.count_documents({'chat_id': chat_id, 'user_id': user_id})
button = InlineKeyboardMarkup().add(InlineKeyboardButton(
"⚠️ Remove warn", callback_data='remove_warn_{}'.format(warn_id)
))
# TODO(Rules button)
if warn_limit := await db.warnlimit.find_one({'chat_id': chat_id}):
max_warn = int(warn_limit['num'])
async def enable_all(message, chat, strings):
# Ensure that something is disabled
if not await db.disabled.find_one({"chat_id": chat["chat_id"]}):
await message.reply(
strings["not_disabled_anything"].format(chat_title=chat["chat_title"])
)
return
text = strings["enable_all_text"].format(chat_name=chat["chat_title"])
buttons = InlineKeyboardMarkup()
buttons.add(
InlineKeyboardButton(
strings["enable_all_btn_yes"], callback_data="enable_all_notes_cb"
)
)
buttons.add(
InlineKeyboardButton(strings["enable_all_btn_no"], callback_data="cancel")
)
await message.reply(text, reply_markup=buttons)
def CurrenciesMenuMarkup(chatID: str, chatType: str) -> InlineKeyboardMarkup:
lang = DBH.GetSetting(chatID, "lang", chatType)
dictLang = ButtonTexts[lang]
CurrenciesMenuMU = InlineKeyboardMarkup()
CurrenciesMenuMU.add(InlineKeyboardButton("A", callback_data="cur_a"))
CurrenciesMenuMU.add(InlineKeyboardButton("B", callback_data="cur_b"))
CurrenciesMenuMU.add(InlineKeyboardButton("C", callback_data="cur_c"))
CurrenciesMenuMU.add(InlineKeyboardButton("D-F", callback_data="cur_df"))
CurrenciesMenuMU.add(InlineKeyboardButton("G-H", callback_data="cur_gh"))
CurrenciesMenuMU.add(InlineKeyboardButton("I-J", callback_data="cur_ij"))
CurrenciesMenuMU.add(InlineKeyboardButton("K-L", callback_data="cur_kl"))
CurrenciesMenuMU.add(InlineKeyboardButton("M", callback_data="cur_m"))
CurrenciesMenuMU.add(InlineKeyboardButton("N-Q", callback_data="cur_nq"))
CurrenciesMenuMU.add(InlineKeyboardButton("R-S", callback_data="cur_rs"))
CurrenciesMenuMU.add(InlineKeyboardButton("T-U", callback_data="cur_tu"))
CurrenciesMenuMU.add(InlineKeyboardButton("V-Y", callback_data="cur_vy"))
CurrenciesMenuMU.add(
InlineKeyboardButton(dictLang['back'], callback_data="cur_menu"))
return CurrenciesMenuMU
async def get_mod_help_callback(query, callback_data=False, **kwargs):
chat_id = query.message.chat.id
message = query.message
module = callback_data['module']
text = get_string(module, "title", chat_id, dir="HELPS")
text += '\n'
lang = get_chat_lang(chat_id)
buttons = InlineKeyboardMarkup(row_width=2)
for string in get_string(module, "text", chat_id, dir="HELPS"):
text += LANGUAGES[lang]["HELPS"][module]['text'][string]
text += '\n'
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 select_issue(user: User, data: dict):
keyboard = InlineKeyboardMarkup(row_width=2)
journal = Journal.get(Journal.id == data['journal_id'])
year = data.get('year', 2021)
for journal_issue in JournalIssue.select().where(
JournalIssue.journal == journal,
JournalIssue.year == year).order_by(JournalIssue.number):
if len(journal_issue.articles) == 0:
continue
callback_data = { # max length 64 symbols
'action': 'select_article',
'journal_issue_id': journal_issue.id
}
keyboard.add(
InlineKeyboardButton(
text=f"№{journal_issue.number}|{journal_issue.title}",
callback_data=json.dumps(callback_data)))
await bot.send_message(user.user_id,
'Выберите номер журнала:',
reply_markup=keyboard)
async def change_lang(message, lang, e=False):
chat_id = message.chat.id
await change_chat_lang(chat_id, lang)
strings = await get_strings(chat_id, 'language')
lang_info = LANGUAGES[lang]['language_info']
text = strings['lang_changed'].format(lang_name=lang_info['flag'] + " " + lang_info['babel'].display_name)
text += strings['help_us_translate']
markup = InlineKeyboardMarkup()
if 'translators' in lang_info:
markup.add(InlineKeyboardButton(strings['see_translators'], callback_data=translators_lang_cb.new(lang=lang)))
if e:
await message.edit_text(text, reply_markup=markup, disable_web_page_preview=True)
else:
await message.reply(text, reply_markup=markup, disable_web_page_preview=True)
async def report_error(query):
channel_id = get_config_key("errors_channel")
chat_id = query.message.chat.id
if await is_user_admin(chat_id, query.from_user.id) is False:
await query.answer("Only admins can report errors!")
return
await bot.forward_message(channel_id, chat_id, query.message.message_id)
buttons = InlineKeyboardMarkup(row_width=1).add(
InlineKeyboardButton(
"Delete message",
callback_data='get_delete_msg_{}_admin'.format(chat_id)))
text = "<b>Sorry, I encountered a error!</b>\n"
text += "Error reported, your report file will be erased in 3 weeks.\n"
text += "<a href=\"https://t.me/SophieSupport\">Sophie support chat</a>"
await query.message.edit_caption(text, reply_markup=buttons)
await query.answer("Error reported! Thank you.")
async def change_device_info(message, device, edit=False):
await ChangeDeviceState.list_info.set()
codename = device['codename']
text = "Device name: " + device['fullname']
text += "\nCodename: " + codename
text += "\nMaintainer: " + device['maintainer']
text += "\nStatus: " + device['status']
if 'default_bugs' in device:
text += "\nDefault builds bugs:\n" + device['default_bugs']
if 'default_notes' in device:
text += "\nDefault builds notes:\n" + device['default_notes']
buttons = InlineKeyboardMarkup(row_width=2).add(
InlineKeyboardButton("Change maintainer", callback_data=fox_change_maintainer_cp.new(codename=codename)),
InlineKeyboardButton("Change development status", callback_data=fox_change_status_cp.new(codename=codename))
)
if 'default_bugs' not in device:
buttons.add(InlineKeyboardButton("Add default bugs", callback_data=fox_change_def_bugs_cp.new(codename=codename)))
else:
buttons.add(
InlineKeyboardButton("Edit default bugs", callback_data=fox_change_def_bugs_cp.new(codename=codename)),
InlineKeyboardButton("Delete default bugs", callback_data=fox_del_def_bugs_cp.new(codename=codename))
)
if 'default_notes' not in device:
buttons.add(InlineKeyboardButton("Add default notes", callback_data=fox_change_def_notes_cp.new(codename=codename)))
else:
buttons.add(
InlineKeyboardButton("Edit default notes", callback_data=fox_change_def_notes_cp.new(codename=codename)),
InlineKeyboardButton("Delete default notes", callback_data=fox_del_def_notes_cp.new(codename=codename))
)
buttons.add(
InlineKeyboardButton("Done", callback_data='cancel')
)
if edit is True:
await message.edit_text(text, reply_markup=buttons)
else:
await message.reply(text, reply_markup=buttons)
async def change_device_status(query, callback_data, state):
codename = callback_data['codename']
await ChangeDeviceState.change_status.set()
buttons = InlineKeyboardMarkup(row_width=1).add(
InlineKeyboardButton("Maintained",
callback_data=fox_change_status_btn_cp.new(
codename=codename, status=1)),
InlineKeyboardButton("Maintained without device on hands",
callback_data=fox_change_status_btn_cp.new(
codename=codename, status=2)),
InlineKeyboardButton("Testing only",
callback_data=fox_change_status_btn_cp.new(
codename=codename, status=3)),
InlineKeyboardButton("Unmaintained",
callback_data=fox_change_status_btn_cp.new(
codename=codename, status=4)),
)
await query.message.edit_text("Select device status:",
reply_markup=buttons)
def CurrenciesSetupMarkup(chatID: str, chatType: str,
letter: str) -> InlineKeyboardMarkup:
lang = DBH.GetSetting(chatID, "lang", chatType)
dictLang = ButtonTexts[lang]
AllCurrencies = ListsCache.GetListOfCur()
TurnedOnCurrencies = DBH.GetAllCurrencies(chatID)
AllFlags = ListsCache.GetDictOfFlags()
CurrenciesSetupMU = InlineKeyboardMarkup()
if len(letter) == 1:
letter = letter.upper()
for i in AllCurrencies:
if i[0] == letter:
if i in TurnedOnCurrencies:
CurrenciesSetupMU.add(
InlineKeyboardButton(AllFlags[i] + i + " ✅",
callback_data="cur_" + i))
else:
CurrenciesSetupMU.add(
InlineKeyboardButton(AllFlags[i] + i + " ❌",
callback_data="cur_" + i))
else:
firstLetter = ord(letter[0].upper())
lastLetter = ord(letter[1].upper())
listOfLetters = []
while firstLetter <= lastLetter:
listOfLetters.append(chr(firstLetter))
firstLetter += 1
for i in AllCurrencies:
if i[0] in listOfLetters:
if i in TurnedOnCurrencies:
CurrenciesSetupMU.add(
InlineKeyboardButton(AllFlags[i] + i + " ✅",
callback_data="cur_" + i))
else:
CurrenciesSetupMU.add(
InlineKeyboardButton(AllFlags[i] + i + " ❌",
callback_data="cur_" + i))
CurrenciesSetupMU.add(
InlineKeyboardButton(dictLang['back'], callback_data="cur_curmenu"))
return CurrenciesSetupMU
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=False if edit is False else True
),
)
)
markup.add(
InlineKeyboardButton(
strings["crowdin_btn"], url="https://crowdin.com/project/DaisyXx"
)
)
if edit:
markup.add(InlineKeyboardButton(strings["back"], callback_data="go_to_start"))
with suppress(MessageNotModified):
await task(text, reply_markup=markup)
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)
def SettingsMarkup(chatID: str, chatType: str) -> InlineKeyboardMarkup:
lang = DBH.GetSetting(chatID, "lang", chatType)
isDeleteButton = DBH.GetSetting(chatID, "deleteButton", chatType)
dictLang = ButtonTexts[lang]
SettingsMU = InlineKeyboardMarkup()
SettingsMU.add(
InlineKeyboardButton(dictLang['currencies'], callback_data="cur_menu"))
SettingsMU.add(
InlineKeyboardButton(dictLang['lang'], callback_data="lang_menu"))
SettingsMU.add(
InlineKeyboardButton(dictLang['delete_button'],
callback_data="delbut_menu"))
SettingsMU.add(
InlineKeyboardButton(dictLang['flags'], callback_data="flags_menu"))
if chatType != "private":
SettingsMU.add(
InlineKeyboardButton(dictLang['permisssions'],
callback_data="edit_menu"))
if isDeleteButton:
SettingsMU.add(
InlineKeyboardButton(dictLang['delete'], callback_data="delete"))
return SettingsMU
async def connect_to_chat_direct(message, strings):
user_id = message.from_user.id
chat_id = message.chat.id
if user_id == 1087968824:
# just warn the user that connections with admin rights doesn't work
return await message.reply(strings['anon_admin_conn'],
reply_markup=InlineKeyboardMarkup().add(
InlineKeyboardButton(
strings['click_here'],
callback_data="anon_conn_cb")))
chat = await db.chat_list.find_one({'chat_id': chat_id})
chat_title = chat['chat_title'] if chat is not None else message.chat.title
text = strings['pm_connected'].format(chat_name=chat_title)
try:
await bot.send_message(user_id, text)
await def_connect_chat(message, user_id, chat_id, chat_title)
except (BotBlocked, CantInitiateConversation):
await message.reply(
strings['connected_pm_to_me'].format(chat_name=chat_title))
redis.set('AllMight_connected_start_state:' + str(user_id), 1)
async def change_captcha(event, strings, state=None, **kwargs):
message = event.message
async with state.proxy() as data:
data['regen_num'] = 1 if 'regen_num' not in data else data['regen_num'] + 1
regen_num = data['regen_num']
if regen_num > 3:
img, num = generate_captcha(number=data['captcha_num'])
text = strings['last_chance']
await message.edit_media(InputMediaPhoto(img, caption=text))
return
img, num = generate_captcha()
data['captcha_num'] = num
text = strings['ws_captcha_text'].format(user=await get_user_link(event.from_user.id))
buttons = InlineKeyboardMarkup().add(InlineKeyboardButton(
strings['regen_captcha_btn'],
callback_data='regen_captcha'
))
await message.edit_media(InputMediaPhoto(img, caption=text), reply_markup=buttons)
def LanguageMenuMarkup(chatID: str, chatType: str):
def RulesMark(lang: str, answDict) -> str:
if answDict['lang'] == lang:
return " ✅"
else:
return " ❌"
lang = DBH.GetSetting(chatID, "lang", chatType)
AllSettings = DBH.GetAllSettings(chatID, chatType)
dictLang = ButtonTexts[lang]
LanguageMenuMU = InlineKeyboardMarkup()
LanguageMenuMU.add(
InlineKeyboardButton("🇬🇧EN" + RulesMark('en', AllSettings),
callback_data="lang_en"))
LanguageMenuMU.add(
InlineKeyboardButton("🇷🇺RU" + RulesMark('ru', AllSettings),
callback_data="lang_ru"))
LanguageMenuMU.add(
InlineKeyboardButton("🇺🇦UA" + RulesMark('ua', AllSettings),
callback_data="lang_ua"))
LanguageMenuMU.add(
InlineKeyboardButton(dictLang['back'], callback_data="settings"))
return LanguageMenuMU
async def get_start_func(message, strings, edit=False):
msg = message.message if hasattr(message, 'message') else message
task = msg.edit_text if edit else msg.reply
buttons = InlineKeyboardMarkup()
buttons.add(
InlineKeyboardButton(strings['btn_help'], callback_data='get_help'))
buttons.add(
InlineKeyboardButton(strings['btn_lang'], callback_data='lang_btn'),
InlineKeyboardButton(strings['btn_source'],
url='https://github.com/TeamDaisyX/'))
buttons.add(
InlineKeyboardButton(strings['btn_channel'],
url='https://t.me/DaisyXUpdates'),
InlineKeyboardButton('👥 Support Grup',
url='https://t.me/DaisyXUpdates'))
buttons.add(
InlineKeyboardButton(
"👸🏼 Add DaisyX to your group",
url=f'https://telegram.me/daisyxbot?startgroup=true'))
# Handle error when user click the button 2 or more times simultaneously
with suppress(MessageNotModified):
await task(strings['start_hi'], reply_markup=buttons)
