await get_greetings_data.reset_cache(chat_id)
try:
await message.reply(text)
except BadRequest:
await message.answer(text)
else:
text = strings['welcomemute_invalid_arg']
try:
await message.reply(text)
except BadRequest:
await message.answer(text)
# Welcome Security
wlcm_sec_config_proc = CallbackData("wlcm_sec_proc", "chat_id", "user_id",
"level")
wlcm_sec_config_cancel = CallbackData("wlcm_sec_cancel", "user_id", "level")
class WelcomeSecurityConf(StatesGroup):
send_time = State()
@register(cmds='welcomesecurity', user_admin=True)
@chat_connection(admin=True, only_groups=True)
@get_strings_dec('greetings')
async def welcome_security(message, chat, strings):
chat_id = chat['chat_id']
if len(args := message.get_args().lower().split()) < 1:
db_item = await get_greetings_data(chat_id)
from aiogram.types.inline_keyboard import InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.utils.callback_data import CallbackData
from aiogram.utils.deep_linking import get_start_link
from aiogram.utils.exceptions import BotBlocked, CantInitiateConversation
from utah import bot
from utah.decorator import register
from utah.services.mongo import db
from utah.services.redis import redis
from .utils.connections import chat_connection, set_connected_chat, get_connection_data
from .utils.language import get_strings_dec
from .utils.message import get_arg
from .utils.notes import BUTTONS
from .utils.user_details import get_chat_dec, is_user_admin
connect_to_chat_cb = CallbackData('connect_to_chat_cb', 'chat_id')
@get_strings_dec('connections')
async def def_connect_chat(message, user_id, chat_id, chat_title, strings, edit=False):
await set_connected_chat(user_id, chat_id)
text = strings['pm_connected'].format(chat_name=chat_title)
if edit:
await message.edit_text(text)
else:
await message.reply(text)
# In chat - connect directly to chat
@register(cmds='connect', only_groups=True, no_args=True)
from aiogram.utils.callback_data import CallbackData
search_callback = CallbackData("action", "action_name")
import random
from contextlib import suppress
from aiogram.types.inline_keyboard import InlineKeyboardButton, InlineKeyboardMarkup
from aiogram.utils.callback_data import CallbackData
from aiogram.utils.exceptions import MessageNotModified
from DaisyX.decorator import register
from DaisyX.modules.utils.disable import disableable_dec
from . import MOD_HELP
from .language import select_lang_keyboard
from .utils.disable import disableable_dec
from .utils.language import get_strings_dec
helpmenu_cb = CallbackData("helpmenu", "mod")
def help_markup(modules):
markup = InlineKeyboardMarkup()
for module in modules:
markup.insert(
InlineKeyboardButton(module,
callback_data=helpmenu_cb.new(mod=module)))
return markup
STICKERS = (
"CAACAgUAAxkBAAJOGmBeli95P073FKVkgc4esfKE4UlXAAIOAgACyavAVkbLMIidWYdyHgQ",
"CAACAgUAAxkBAAJOG2BeljABwlCfwzHT1gzyiciBri6_AAIsAgACXBPBVgpGQRz-1qmlHgQ",
"CAACAgUAAxkBAAJOHGBeljOJ35CQNnkpnVcgRoHuJX6DAAL3AQACN8TBVm1PIART01cWHgQ",
from aiogram.types import ReplyKeyboardRemove, \
ReplyKeyboardMarkup, InlineKeyboardMarkup, \
InlineKeyboardButton
from aiogram.utils.callback_data import CallbackData
from loguru import logger
start_cb = CallbackData('skip', 'new_game')
def start():
markup = InlineKeyboardMarkup()
markup.add(
InlineKeyboardButton("НАЧАТЬ",
callback_data=start_cb.new(new_game='new_game')))
return markup
POSTS = {
str(uuid.uuid4()): {
'title':
f'Post {index}',
'body':
'Lorem ipsum dolor sit amet, '
'consectetur adipiscing elit, '
'sed do eiusmod tempor incididunt ut '
'labore et dolore magna aliqua',
'votes':
random.randint(-2, 5),
}
for index in range(1, 6)
}
posts_cb = CallbackData('post', 'id', 'action') # post:<id>:<action>
def get_keyboard() -> types.InlineKeyboardMarkup:
"""
Generate keyboard with list of posts
"""
markup = types.InlineKeyboardMarkup()
for post_id, post in POSTS.items():
markup.add(
types.InlineKeyboardButton(post['title'],
callback_data=posts_cb.new(
id=post_id, action='view')), )
return markup
from aiogram.utils.callback_data import CallbackData
menu_callback = CallbackData('decision', 'item_name')
WEBHOOK_URL = f"https://{DOMAIN}{WEBHOOK_PATH}"
REDIS_URL = os.getenv('REDIS_URL', '')
LAST_ORG = 'last_organizer_id'
bot = Bot(token=TELEGRAM_TOKEN)
bot.users = {}
bot.payments = set()
bot.orders = {}
bot.organizer = None
bot.order_message = None
bot.payments_message = None
bot.discount = 30
dp = Dispatcher(bot)
rds = redis.Redis.from_url(REDIS_URL)
hin_cb = CallbackData('hin', 'type', 'amount')
disc_cb = CallbackData('discount', 'multiplier')
pay_cb = CallbackData('payment', 'status')
h_types = {'ВК': 50, 'ВБ': 50, 'ЖК': 55, 'ЖБ': 55}
h_amounts = ('-4', '-2', '-1', '0', '+1', '+2', '+4')
@contextmanager
def ignored(exc):
try:
yield
except exc:
pass
from aiogram.utils.callback_data import CallbackData
from aiogram.utils.deep_linking import get_start_link
from aiogram.utils.exceptions import BotBlocked, CantInitiateConversation
from RaVaN import bot
from RaVaN.decorator import register
from RaVaN.services.mongo import db
from RaVaN.services.redis import redis
from .utils.connections import chat_connection, get_connection_data, set_connected_chat
from .utils.language import get_strings_dec
from .utils.message import get_arg
from .utils.notes import BUTTONS
from .utils.user_details import get_chat_dec, is_user_admin
connect_to_chat_cb = CallbackData("connect_to_chat_cb", "chat_id")
@get_strings_dec("connections")
async def def_connect_chat(message,
user_id,
chat_id,
chat_title,
strings,
edit=False):
await set_connected_chat(user_id, chat_id)
text = strings["pm_connected"].format(chat_name=chat_title)
if edit:
await message.edit_text(text)
else:
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.utils.callback_data import CallbackData
from loader import db
steps_data = CallbackData(
"show_menu",
"level",
"select_os_app",
"select_tarif",
)
def make_callback_data(level,
select_os_or_app="0",
select_os_app="0",
select_tarif="0"):
return steps_data.new(level=level,
select_os_or_app=select_os_or_app,
select_os_app=select_os_app,
select_tarif=select_tarif)
async def select_tarif_line_keyboard():
markup = InlineKeyboardMarkup()
markup.insert(InlineKeyboardButton(text='Старт', callback_data='start'))
markup.insert(
InlineKeyboardButton(text='Стандарт', callback_data='standard'))
markup.insert(
InlineKeyboardButton(text='Высокочастотные', callback_data='turbo'))
markup.insert(
InlineKeyboardButton(text='Выделенные', callback_data='dedicated'))
from aiogram.utils.callback_data import CallbackData
buy_callback = CallbackData("buy", "item_name", "quantity")
from texas.services.telethon import tbot
from .utils.connections import get_connected_chat, chat_connection
from .utils.language import get_strings_dec, get_strings, get_string
from .utils.message import need_args_dec, get_cmd
from .utils.restrictions import ban_user, unban_user
from .utils.user_details import (is_chat_creator, get_user_link,
get_user_and_text, check_admin_rights,
is_user_admin, get_chat_dec)
from ..utils.cached import cached
class ImportFbansFileWait(StatesGroup):
waiting = State()
delfed_cb = CallbackData('delfed_cb', 'fed_id', 'creator_id')
# functions
async def get_fed_f(message):
chat = await get_connected_chat(message, admin=True)
if 'err_msg' not in chat:
if chat['status'] == 'private':
# return fed which user is created
fed = await get_fed_by_creator(chat['chat_id'])
else:
fed = await db.feds.find_one({'chats': {'$in': [chat['chat_id']]}})
if not fed:
return False
return fed
from sophie_bot.modules.users import user_admin_dec, user_link, get_chat_admins, user_link_html
from sophie_bot.modules.warns import randomString
from sophie_bot.modules.helper_func.decorators import need_args_dec
# State
class NewFilter(StatesGroup):
handler = State()
action = State()
time = State()
note_name = State()
reason = State()
answer = State()
new_filter_cb = CallbackData('new_filter', 'action')
new_filter_time_cb = CallbackData('select_filter_time', 'time')
@decorator.register()
async def check_message(message):
chat_id = message.chat.id
filters = redis.lrange('filters_cache_{}'.format(chat_id), 0, -1)
if not filters:
update_handlers_cache(chat_id)
filters = redis.lrange('filters_cache_{}'.format(chat_id), 0, -1)
if redis.llen('filters_cache_{}'.format(chat_id)) == 0:
return
text = message.text
if text.split()[0][1:] == 'delfilter':
return
from aiogram.utils.callback_data import CallbackData
like_callback = CallbackData('count_like', 'action')
import contextvars
import functools
from concurrent.futures import ThreadPoolExecutor
from aiogram.utils.callback_data import CallbackData
from aiogram import types
from bot.misc import loop
_executor = ThreadPoolExecutor()
reaction_cd = CallbackData('rctn', 'r')
settings_cd = CallbackData('settings', 'set')
lang_cd = CallbackData('lang', 'lang')
page_cd = CallbackData('page', 'page')
word_cd = CallbackData('word', 'word')
def aiowrap(func):
"""
Wrapping for use sync func in async code
"""
@functools.wraps(func)
def wrapping(*args, **kwargs):
new_func = functools.partial(func, *args, **kwargs)
ctx = contextvars.copy_context()
ctx_func = functools.partial(ctx.run, new_func)
return loop.run_in_executor(_executor, ctx_func)
return wrapping
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton, ReplyKeyboardMarkup, KeyboardButton
from aiogram.utils.callback_data import CallbackData
rooms_callback = CallbackData('chose_rooms', 'number_of_rooms')
start_subscription = CallbackData('subscription', 'action')
def start_keys():
return InlineKeyboardMarkup(
inline_keyboard=[
[InlineKeyboardButton(text="✅Aktywuj wyszukiwanie", callback_data=start_subscription.new(action='next'))],
[InlineKeyboardButton(text="✉️Skontaktuj się z deweloperem", url='telegram.me/dimazmn')]])
final_keys = InlineKeyboardMarkup(
inline_keyboard=[
[InlineKeyboardButton(text="✅Aktywuj wyszukiwanie", callback_data=start_subscription.new(action='next'))],
[InlineKeyboardButton(text="📤️Poleć znajomym", switch_inline_query='Cześć! Szukasz mieszkania we Wrocławiu?'
'Mogę Ci w tym pomoc.')],
[InlineKeyboardButton(text="✉️Skontaktuj się z deweloperem", url='telegram.me/dimazmn')]
])
def rooms_key():
return InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text='Kawalerka', callback_data='number_of_rooms:one')],
[InlineKeyboardButton(text='2 pokoje', callback_data='number_of_rooms:two')],
[InlineKeyboardButton(text='3 pokoje', callback_data='number_of_rooms:three')],
[InlineKeyboardButton(text='4 pokoje i więcej', callback_data='number_of_rooms:four')],
[InlineKeyboardButton(text='⬅️Wstecz', callback_data='back')]
])
class ChangeDeviceState(StatesGroup):
create_new_device = State()
list_info = State()
change_maintainer = State()
change_status = State()
change_def_bugs = State()
change_def_notes = State()
class AddNewDeviceState(StatesGroup):
device_full_name = State()
# Callback filters
build_type_cp = CallbackData('fox_build_type', 'build_type')
add_new_device_cb = CallbackData('fox_add_new_device_cb', 'codename')
fox_change_maintainer_cp = CallbackData('fox_change_maintainer_cb', 'codename')
fox_change_status_cp = CallbackData('fox_change_status_cb', 'codename')
fox_change_status_btn_cp = CallbackData('fox_change_status_btn_cp', 'codename', 'status')
fox_change_def_bugs_cp = CallbackData('fox_change_def_bugs_cb', 'codename')
fox_del_def_bugs_cp = CallbackData('fox_del_def_bugs_cb', 'codename')
fox_change_def_notes_cp = CallbackData('fox_change_def_notes_cb', 'codename')
fox_del_def_notes_cp = CallbackData('fox_del_def_notes_cb', 'codename')
# Custom decorators
def dev_chat(func):
async def wrapped_1(event, *args, **kwargs):
if hasattr(event, 'message'):
from aiogram.utils.callback_data import CallbackData
from aiogram.utils.exceptions import MessageNotModified
from aiogram.types.inline_keyboard import (
InlineKeyboardMarkup,
InlineKeyboardButton
)
from hitsuki.decorator import register
from hitsuki.modules.utils.disable import disableable_dec
from . import MOD_HELP
from .utils.disable import disableable_dec
from .utils.language import get_strings_dec
from .language import select_lang_keyboard
helpmenu_cb = CallbackData('helpmenu', 'mod')
def help_markup(modules):
markup = InlineKeyboardMarkup()
for module in modules:
markup.insert(InlineKeyboardButton(
module, callback_data=helpmenu_cb.new(mod=module)))
return markup
STICKERS = (
"CAACAgUAAxkBAAIuqWCT-DVtb83XEAmOa0HYg-Rb9OFTAAJFAgACjPwBVDR6LdorPC8sHwQ",
"CAACAgUAAxkBAAIuqmCT-DaudH6dExiGBT-SzDzKNo2wAALHAQACRYoBVM_ChXYV21L-HwQ",
"CAACAgUAAxkBAAIuq2CT-D1Fl40xKccMKfAlnfFCKBNmAALrAQACa6MBVEMJy6tsBUpCHwQ",
"CAACAgUAAxkBAAIurGCT-EI6PYxVAkwdE5Qtq8vt2bzDAALsAQAChWsAAVRjYQbBKdY9Fx8E",
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.utils import executor
from aiogram.utils.callback_data import CallbackData
from processor import PlotWidget
bot = Bot(token="1353236117:AAFqai-3H3yc9bDJgzO_NlY8zExA0FQvu8A")
storage = MemoryStorage()
disp = Dispatcher(bot, storage=storage)
disp.middleware.setup(LoggingMiddleware())
processor_cb = CallbackData("process", "action") # post:<id>:<action>
class StateMachine(StatesGroup):
form_input = State()
class Actions(str, Enum):
PLOTTING = "plotting"
@disp.message_handler(commands=["start", "help"])
async def start_handler(message: types.Message):
await message.answer("Доступные действия:", reply_markup=get_keyboard())
from aiogram.utils.callback_data import CallbackData
some_callback = CallbackData("new")
from aiogram.utils.callback_data import CallbackData
setup_callback = CallbackData("action", "action_name")
from typing import Iterable
from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
from aiogram.utils.callback_data import CallbackData
from app.models import Route
from app.types import Bell
from app.utils import uchar
cd_routes = CallbackData('routes_menu', 'action', 'route_id')
def kb_route_buttons(route_id: int, is_active: bool) -> InlineKeyboardMarkup:
"""Display keyboard for selected route.
:param int route_id: Selected route id.
:param bool is_active: Is route notifications active.
"""
bell = Bell.by_state(not is_active)
toggle = ('Отключить уведомления'
if bool(is_active) else 'Включить уведомления')
return InlineKeyboardMarkup(inline_keyboard=[
[
InlineKeyboardButton(
f'{uchar.EYES} Показать маршрут',
callback_data=cd_routes.new(action='show', route_id=route_id),
)
],
[
InlineKeyboardButton(
f'{uchar.CLOCK} Настроить расписание',
from bson.objectid import ObjectId
from pymongo import UpdateOne
from AuraX import bot, loop
from AuraX.decorator import register
from AuraX.modules import LOADED_MODULES
from AuraX.services.mongo import db
from AuraX.services.redis import redis
from AuraX.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 = []
import decimal
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.utils.callback_data import CallbackData
from django.db.models import QuerySet
from django_project.telegrambot.usersmanage.models import Goods, Address, GoodsAndAddress
from utils.database.commands.commands_goods import count_and_return_goods_cities, select_goods_quantity
from utils.database.commands.commands_goodsandaddress import select_goods_addresses
from utils.database.commands.commands_payment import select_all_payments
purchase_cd = CallbackData("purchase", "level", "goods_pk", "city", "address",
"quantity", "payment", "amount_cost")
quantity_cd = CallbackData("quantity_btn", "operation", "quantity", "goods_pk",
"city", "address")
order_cd = CallbackData("order", "goods_pk", "city", "address", "quantity",
"payment", "amount_cost")
def make_purchase_cd(level,
goods_pk,
city="0",
address="0",
quantity="1",
payment="0",
amount_cost="0") -> str:
return purchase_cd.new(level=level,
goods_pk=goods_pk,
city=city,
address=address,
from config import lp_token, admin_id
from load_all import dp, bot, _
import asyncio
from aiogram import Bot, Dispatcher, executor, types
from aiogram.contrib.fsm_storage.redis import RedisStorage2
from aiogram.dispatcher import DEFAULT_RATE_LIMIT
from aiogram.dispatcher.handler import CancelHandler, current_handler
from aiogram.dispatcher.middlewares import BaseMiddleware
from aiogram.utils.exceptions import Throttled
db = database.DBCommands()
logging.basicConfig(level=logging.INFO)
# Используем CallbackData для работы с коллбеками, в данном случае для работы с покупкой товаров
buy_item = CallbackData("buy", "item_id")
def rate_limit(limit: int, key=None):
"""
Decorator for configuring rate limit and key in different functions.
:param limit:
:param key:
:return:
"""
def decorator(func):
setattr(func, 'throttling_rate_limit', limit)
if key:
setattr(func, 'throttling_key', key)
return func
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from contextlib import suppress
from aiogram.types.inline_keyboard import InlineKeyboardMarkup, InlineKeyboardButton
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, get_strings_dec, change_chat_lang, get_chat_lang_info, get_strings
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)
# help - get help
# start - start the bot and get help
# subscribe - activate paid features of the bot and check your subscription status
# setlanguage - specify a language you want to learn. You can switch between languages or add new ones any time
# addtext - add a text which you want to learn
# addwords - add words to learn
# wordlist - add a list of words (you will have to add definitions after adding the list)
# learn - learn the words you added
# test - test the words you learned
# show - show all added words in alphabetical order
# delete - delete a word form your dictionary
# settings - specify your language
# stop - cancel everything and restart
#
posts_cb = CallbackData('post', 'data', 'action')
# Test independent loop
@dp.message_handler(commands=['notify'])
async def send_notifications_to_users(message: types.Message):
await admin.send_notifications_to_users(message)
@dp.message_handler(commands=['start'])
async def start_message(message: types.Message):
logger.info("{} ", message.from_user.id)
await generic.start_message(message.from_user.id)
@dp.message_handler(commands=['help'])
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.utils.callback_data import CallbackData
pagination_call = CallbackData("paginator", "key", "page")
# show_item = CallbackData("show_item", "item_id")
def get_page_keyboard(max_pages: int, key="book", page: int = 1):
# Клавиатура будет выглядеть вот так:
# |<< | <5> | >>|
previous_page = page - 1
previous_page_text = "<< "
current_page_text = f"<{page}>"
next_page = page + 1
next_page_text = " >>"
markup = InlineKeyboardMarkup()
if previous_page > 0:
markup.insert(
InlineKeyboardButton(text=previous_page_text,
callback_data=pagination_call.new(
key=key, page=previous_page)))
markup.insert(
InlineKeyboardButton(text=current_page_text,
callback_data=pagination_call.new(
key=key, page="current_page")))
from aiogram.utils.callback_data import CallbackData
report_msg_cb = CallbackData("delmsg", "option", "user_id", "message_ids")
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.utils.callback_data import CallbackData
from utils.db_api.db_commands import get_subcategories, count_items, get_items, get_categories
# Создаем CallbackData-объекты, которые будут нужны для работы с менюшкой
menu_cd = CallbackData("show_menu", "level", "category", "subcategory",
"item_id")
buy_item = CallbackData("buy", "item_id")
# С помощью этой функции будем формировать коллбек дату для каждого элемента меню, в зависимости от
# переданных параметров. Если Подкатегория, или айди товара не выбраны - они по умолчанию равны нулю
def make_callback_data(level, category="0", subcategory="0", item_id="0"):
return menu_cd.new(level=level,
category=category,
subcategory=subcategory,
item_id=item_id)
# Создаем функцию, которая отдает клавиатуру с доступными категориями
async def categories_keyboard():
# Указываем, что текущий уровень меню - 0
CURRENT_LEVEL = 0
# Создаем Клавиатуру
markup = InlineKeyboardMarkup()
# Забираем список товаров из базы данных с РАЗНЫМИ категориями и проходим по нему
categories = await get_categories()
for category in categories: