def generate_inline_buttons_for_click_up_task_control(
is_new_task: bool = False) -> InlineKeyboardMarkup:
choice = InlineKeyboardMarkup(row_width=1)
choice.insert(
InlineKeyboardButton(text="Добавить файл",
callback_data=CallbackData(
"task_control",
"action").new(action="add_file")))
choice.insert(
InlineKeyboardButton(text="Добавить комментарий",
callback_data=CallbackData(
"task_control",
"action").new(action="add_comment")))
if is_new_task is False:
choice.insert(
InlineKeyboardButton(text="Список комментариев",
callback_data=CallbackData(
"task_control",
"action").new(action="list_comment")))
choice.insert(
InlineKeyboardButton(text="Выход",
callback_data=CallbackData(
"task_control",
"action").new(action="cancel")))
return choice
async def test_cb_zero(self):
cb = CallbackData('zero')
assert cb.new() == 'zero'
assert (await cb.filter().check(CallbackQuery(data='zero'))) == {
'callback_data': {
'@': 'zero'
}
}
assert (await cb.filter().check(CallbackQuery(data='zero:'))) is False
assert (await cb.filter().check(CallbackQuery(data='bla'))) is False
def create_coeff_leagues_keyboard(callback: CallbackData):
country_keyboard = InlineKeyboardMarkup(row_width=1)
for league in coeff_manager.get_leagues():
country_keyboard.insert(InlineKeyboardButton(
text=str(coeff_manager.emojize_league(league) + ' ' + coeff_manager.translate_league(league)),
callback_data=callback.new(league_name=league, round="cur")
))
country_keyboard.insert(InlineKeyboardButton(
text=emojize(":leftwards_arrow_with_hook: Назад"),
callback_data=callback.new(league_name="cancel", round="cur")
))
return country_keyboard
def generate_inline_buttons_for_click_up_check_data() -> InlineKeyboardMarkup:
choice = InlineKeyboardMarkup(row_width=1)
choice.insert(
InlineKeyboardButton(text="Создать",
callback_data=CallbackData(
"create_task",
"action").new(action="Создать")))
choice.insert(
InlineKeyboardButton(text="Отменить",
callback_data=CallbackData(
"create_task",
"action").new(action="Отменить")))
return choice
def create_player_back_keyboard(callback: CallbackData):
player_back_keyboard = InlineKeyboardMarkup(row_width=1)
player_back_button = InlineKeyboardButton(
text=emojize(":leftwards_arrow_with_hook: Назад"),
callback_data=callback.new(league_name="back_to_list"))
player_back_keyboard.add(player_back_button)
return player_back_keyboard
def generate_inline_buttons_for_click_up_add_files() -> InlineKeyboardMarkup:
choice = InlineKeyboardMarkup(row_width=1)
choice.insert(
InlineKeyboardButton(text="Добавить еще",
callback_data=CallbackData(
"task_control",
"action").new(action="add_file")))
choice.insert(
InlineKeyboardButton(text="Выход",
callback_data=CallbackData(
"task_control",
"action").new(action="cancel")))
return choice
def __init__(self):
self.parent = EnglishWordMenu()
self.data = (
('back', 'back'),
('ready', 'ready'),
)
self.prefix = 'EnglishWordMenuEnterRussianWord'
self.callback_data = CallbackData(self.prefix, 'action')
class CalendarMultiNotification:
cd = CallbackData('es', 'ids', 'action')
@staticmethod
def encode_ids(episodes: List[int]):
ids = [compress_int(id) for id in episodes]
return ','.join(ids) or '-'
@staticmethod
def decode_ids(ids: str):
if ids == '-':
return []
ids = ids.split(',')
ids = [decompress_int(id) for id in ids]
return ids
@classmethod
async def markup(cls,
se: ShowEpisode,
episodes_ids: List[int],
watched: bool,
index=0):
prev_ids = cls.encode_ids(episodes_ids[:index])
cur_id = cls.encode_ids(episodes_ids[index:index + 1])
next_ids = cls.encode_ids(episodes_ids[index + 1:])
mark = '✅' if watched else '❌'
row = [
IKB('👈️' if index > 0 else '🤛',
callback_data=cls.cd.new(ids=prev_ids, action='prev')),
IKB(f'{mark} {se.episode.season}x{se.episode.number}',
callback_data=cls.cd.new(ids=cur_id, action='watch')),
IKB('👉' if index < len(episodes_ids) - 1 else '🤜',
callback_data=cls.cd.new(ids=next_ids, action='next')),
]
kb = InlineKeyboardMarkup(inline_keyboard=[row])
if not watched:
kb.add(*[
IKB(source, url=str(url))
async for source, url in watch_urls(se.show, se.episode)
])
return kb
@classmethod
async def send(cls, bot: Bot, trakt: TraktClient, storage: Storage,
user_id: str, episodes: List[CalendarEpisode]):
first = episodes[0]
text = rendering.render_html(
'calendar_multi_notification',
show=first.show,
episodes=episodes,
)
creds = await storage.get_creds(user_id)
sess = trakt.auth(creds.access_token)
watched = await sess.watched(first.episode.id)
episodes_ids = [cs.episode.id for cs in episodes]
keyboard_markup = await cls.markup(first, episodes_ids, watched)
await bot.send_message(user_id, text, reply_markup=keyboard_markup)
def create_coeff_back_keyboard(callback: CallbackData, league_name: str, cur_round: bool):
coeff_back_keyboard = InlineKeyboardMarkup(row_width=2)
coeff_back_button = InlineKeyboardButton(
text=emojize(":leftwards_arrow_with_hook: Назад"),
callback_data=callback.new(league_name="back_to_list", round="cur")
)
if cur_round:
coeff_round_button = InlineKeyboardButton(
text=emojize("➡️ Cледующий тур"),
callback_data=callback.new(league_name=league_name, round="next")
)
else:
coeff_round_button = InlineKeyboardButton(
text=emojize("⬅️ Текущий тур"),
callback_data=callback.new(league_name=league_name, round="cur")
)
coeff_back_keyboard.add(coeff_back_button, coeff_round_button)
return coeff_back_keyboard
def __init__(self):
self.parent = None
self.data = (
('englishword', 'English word'),
('russianword', 'Russian word'),
('myvocabulary', 'My vocabulary'),
)
self.prefix = 'MainMenu'
self.callback_data = CallbackData(self.prefix, 'action')
def create_sources_back_keyboard(callback: CallbackData):
sources_back_keyboard = InlineKeyboardMarkup(row_width=1)
sources_back_button = InlineKeyboardButton(
text=emojize(":leftwards_arrow_with_hook: Назад"),
callback_data=callback.new(league_name="back_to_list",
name="None",
url="None",
action="None"))
sources_back_keyboard.add(sources_back_button)
return sources_back_keyboard
def create_sources_league_keyboard(callback: CallbackData, league_name: str):
league_keyboard = InlineKeyboardMarkup(row_width=1)
sources_add_button = InlineKeyboardButton(
text=emojize(":newspaper: Добавить источник"),
callback_data=callback.new(league_name=league_name, action="add"))
league_keyboard.add(sources_add_button)
sources_delete_button = InlineKeyboardButton(
text=emojize(":wastebasket: Удалить источник"),
callback_data=callback.new(league_name=league_name, action="delete"))
league_keyboard.add(sources_delete_button)
sources_back_button = InlineKeyboardButton(
text=emojize(":leftwards_arrow_with_hook: Назад"),
callback_data=callback.new(league_name="back_to_list", action="None"))
league_keyboard.add(sources_back_button)
return league_keyboard
async def test_cb(self):
cb = CallbackData('simple', 'action')
assert cb.new('x') == 'simple:x'
assert cb.new(action='y') == 'simple:y'
assert cb.new('') == 'simple:'
assert (await cb.filter().check(CallbackQuery(data='simple:'))) == {
'callback_data': {
'@': 'simple',
'action': ''
}
}
assert (await cb.filter().check(CallbackQuery(data='simple:x'))) == {
'callback_data': {
'@': 'simple',
'action': 'x'
}
}
assert (await cb.filter(action='y').check(
CallbackQuery(data='simple:x'))) is False
def generate_inline_buttons_for_click_up_tags(tags: list) -> dict:
choice = InlineKeyboardMarkup(row_width=1)
for tag in tags:
choice.insert(
InlineKeyboardButton(text=tag[1],
callback_data=CallbackData(
"tags", "name").new(name=tag[0])))
return dict(response="Список тегов (Выбор нескольких вариантов):",
keyboards=choice)
def generate_inline_buttons_for_click_up_priority(priorities: list) -> dict:
choice = InlineKeyboardMarkup(row_width=1)
for priority in priorities:
choice.insert(
InlineKeyboardButton(text=priority[1],
callback_data=CallbackData(
"priorities",
"name").new(name=priority[0])))
return dict(response="Список приоритетов:", keyboards=choice)
def generate_inline_buttons_for_click_up_lists(folder: FolderData) -> dict:
choice = InlineKeyboardMarkup(row_width=3)
for folder_list in folder.lists:
choice.insert(
InlineKeyboardButton(text=folder_list.name,
callback_data=CallbackData(
"lists", "id",
"name").new(id=folder_list.id,
name=folder_list.name)))
return dict(folder_name=folder.name, keyboards=choice)
def generate_inline_buttons_for_click_up_task_status() -> InlineKeyboardMarkup:
choice = InlineKeyboardMarkup(row_width=3)
for x in ClickUpTaskStatusType:
choice.insert(
InlineKeyboardButton(text=x.preview_name,
callback_data=CallbackData(
"task_status",
"task_group").new(task_group=x.value)))
return choice
def generate_inline_buttons_for_click_up_folders(
data: SpaceData) -> InlineKeyboardMarkup:
choice = InlineKeyboardMarkup(row_width=1)
for folder in data.folders:
choice.insert(
InlineKeyboardButton(text=folder.name[:128],
callback_data=CallbackData(
"folders", "id",
"name").new(id=folder.id,
name=folder.name[:128])))
return choice
class Markups:
cb = CallbackData('dialog', 'id', 'action')
@classmethod
async def dialogs_keyboard(cls,
client: TelegramClient) -> InlineKeyboardMarkup:
markup = InlineKeyboardMarkup()
d: Dialog
async for d in client.iter_dialogs():
button = InlineKeyboardButton(d.title,
callback_data=cls.cb.new(id=d.id,
action='s'))
markup.insert(button)
return markup
class CalendarNotification:
cd = CallbackData('e', 'id', 'watched')
@classmethod
async def markup(cls, se: ShowEpisode, watched: bool, hide: bool):
mark = '✅' if watched else '❌'
cd = cls.cd.new(id=se.episode.ids.trakt,
watched='1' if watched else '0')
watch_btn = IKB(f'{mark} watched', callback_data=cd)
kb = InlineKeyboardMarkup(row_width=5, inline_keyboard=[[watch_btn]])
if not hide or not watched:
kb.add(*[
IKB(source, url=str(url))
async for source, url in watch_urls(se.show, se.episode)
])
return kb
@classmethod
async def send(cls,
bot: Bot,
trakt: TraktClient,
storage: Storage,
user_id,
se: ShowEpisode,
watched: bool = None):
text = rendering.render_html(
'calendar_notification',
show_episode=se,
)
creds, user_pref = await asyncio.gather(
storage.get_creds(user_id),
storage.get_pref(user=user_id),
)
on_watch = user_pref.get('on_watch', 'hide')
sess = trakt.auth(creds.access_token)
if watched is None:
watched = await sess.watched(se.episode.id)
if watched and on_watch == 'delete':
return
keyboard_markup = await cls.markup(se,
watched=watched,
hide=on_watch == 'hide')
await bot.send_message(user_id,
text,
reply_markup=keyboard_markup,
disable_web_page_preview=watched)
def generate_inline_buttons_for_click_up_members(members: UserGroups) -> list:
choices = []
for group, values in members.dict().items():
choice = InlineKeyboardMarkup(row_width=2)
for member in values:
choice.insert(
InlineKeyboardButton(text=member['username'],
callback_data=CallbackData(
"assigned", "id", "username").new(
id=member['id'],
username=member['username'])))
preview_name = getattr(Teams, group).preview_name if getattr(
Teams, group) else "Неизвестно"
choices.append(dict(member_group=preview_name, keyboards=choice))
return choices
def generate_inline_buttons_for_click_up_spaces(data: ClickUpData) -> list:
choices = []
for team in data.teams:
choice = InlineKeyboardMarkup(row_width=1)
for space in team.spaces:
try:
choice.insert(
InlineKeyboardButton(text=space.name[:128],
callback_data=CallbackData(
"spaces", "id", "name").new(
id=space.id,
name=space.name[:128])))
except Exception:
logging.error(f"Callback is wrong:{space.dict()}")
continue
choices.append(dict(team_name=team.name, keyboards=choice))
return choices
async def test_cb_double(self):
cb = CallbackData('double', 'pid', 'action')
assert cb.new('123', 'x') == 'double:123:x'
assert cb.new(pid=456, action='y') == 'double:456:y'
assert cb.new('', 'z') == 'double::z'
assert cb.new('789', '') == 'double:789:'
assert (await cb.filter().check(CallbackQuery(data='double::'))) == {
'callback_data': {
'@': 'double',
'pid': '',
'action': ''
}
}
assert (await cb.filter().check(CallbackQuery(data='double:x:'))) == {
'callback_data': {
'@': 'double',
'pid': 'x',
'action': ''
}
}
assert (await cb.filter().check(CallbackQuery(data='double::y'))) == {
'callback_data': {
'@': 'double',
'pid': '',
'action': 'y'
}
}
assert (await
cb.filter(action='x').check(CallbackQuery(data='double:123:x')
)) == {
'callback_data': {
'@': 'double',
'pid': '123',
'action': 'x'
}
}
from aiogram.utils.callback_data import CallbackData
promo_callback = CallbackData("promo", "command")
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.utils.callback_data import CallbackData
buying_item = CallbackData("buy", "id")
show_item = CallbackData("show", "id")
def buy_keyboard(item_id):
keyboard = InlineKeyboardMarkup(inline_keyboard=[[
InlineKeyboardButton(text="Купить",
callback_data=buying_item.new(id=item_id))
]])
return keyboard
def show_keyboard(item_id):
keyboard = InlineKeyboardMarkup(inline_keyboard=[[
InlineKeyboardButton(text="Показать товар",
callback_data=show_item.new(id=item_id))
]])
return keyboard
from aiogram.utils.callback_data import CallbackData
group_users_data = CallbackData('gud', 'group', 'handler')
change_button_data = CallbackData(
'change_button',
'user_id',
# 'user_name',
# 'user_status',
'type_button')
set_status_data = CallbackData(
'ssb',
'id',
# 'user_name',
'new_st',
'type_btn')
from aiogram.utils.callback_data import CallbackData
from aiogram.utils.exceptions import MessageNotModified
from DaisyX.decorator import register
from DaisyX.services.mongo import db
from .utils.language import (
LANGUAGES,
change_chat_lang,
get_chat_lang_info,
get_strings,
get_strings_dec,
)
from .utils.message import get_arg
select_lang_cb = CallbackData("select_lang_cb", "lang", "back_btn")
translators_lang_cb = CallbackData("translators_lang_cb", "lang")
@register(cmds="lang", no_args=True, user_can_change_info=True)
async def select_lang_cmd(message):
await select_lang_keyboard(message)
@get_strings_dec("language")
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)
from aiogram.utils.callback_data import CallbackData
reg_callback = CallbackData("reg", "bool")
from aiogram.utils.callback_data import CallbackData
from babel.dates import format_timedelta
from DaisyX import dp
from DaisyX.decorator import register
from DaisyX.modules.utils.connections import chat_connection
from DaisyX.modules.utils.language import get_strings, get_strings_dec
from DaisyX.modules.utils.message import convert_time, get_args, need_args_dec
from DaisyX.modules.utils.restrictions import ban_user, kick_user, mute_user
from DaisyX.modules.utils.user_details import get_user_link, is_user_admin
from DaisyX.services.mongo import db
from DaisyX.services.redis import bredis, redis
from DaisyX.utils.cached import cached
from DaisyX.utils.logger import log
cancel_state = CallbackData("cancel_state", "user_id")
class AntiFloodConfigState(StatesGroup):
expiration_proc = State()
@dataclass
class CacheModel:
count: int
class AntifloodEnforcer(BaseMiddleware):
state_cache_key = "floodstate:{chat_id}"
async def enforcer(self, message: Message, database: dict):
from bson.objectid import ObjectId
from pymongo import UpdateOne
from DaisyX import bot, loop
from DaisyX.decorator import register
from DaisyX.modules import LOADED_MODULES
from DaisyX.services.mongo import db
from DaisyX.services.redis import redis
from DaisyX.utils.logger import log
from .utils.connections import chat_connection, get_connected_chat
from .utils.language import get_string, get_strings_dec
from .utils.message import get_args_str, need_args_dec
from .utils.user_details import is_chat_creator, is_user_admin
filter_action_cp = CallbackData("filter_action_cp", "filter_id")
filter_remove_cp = CallbackData("filter_remove_cp", "id")
filter_delall_yes_cb = CallbackData("filter_delall_yes_cb", "chat_id")
FILTERS_ACTIONS = {}
class NewFilter(StatesGroup):
handler = State()
setup = State()
async def update_handlers_cache(chat_id):
redis.delete(f"filters_cache_{chat_id}")
filters = db.filters.find({"chat_id": chat_id})
handlers = []
