def register_add_links_handlers(dp: Dispatcher):
dp.register_message_handler(cmd_add_link, commands="add", state="*")
dp.register_message_handler(cmd_add_link,
CommandStart(deep_link="add"),
state="*")
dp.register_message_handler(link_added, state=Links.add_link_url)
dp.register_message_handler(description_added,
state=Links.add_link_description)
def main():
# Создаем бота и передаем ему ключ для авторизации на серверах Telegram
mybot = Bot(token=API_KEY, proxy=PROXY_URL, proxy_auth=PROXY_AUTH)
dp = Dispatcher(mybot)
@dp.message_handler(CommandStart())
async def greet_user(message: types.Message):
await message.answer('Привет, пользователь! Ты вызвал команду /start')
print('Вызван /start')
@dp.message_handler()
async def talk_to_me(message: types.Message):
await message.answer(message.text)
print(message.text)
if __name__ == '__main__':
logging.info("Бот стартовал")
# Командуем боту начать ходить в Telegram за сообщениями
executor.start_polling(dp, skip_updates=True)
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart, ChatTypeFilter
from aiogram.types import ChatType
from loader import dp
@dp.message_handler(CommandStart(), ChatTypeFilter(ChatType.PRIVATE))
async def bot_start(message: types.Message):
await message.answer(
'Ку привет! Добавь в чат и я буду переводить ваши войсы в текст!')
@register(cmds='start', only_pm=True)
@get_strings_dec('connections')
@chat_connection()
async def connected_start_state(message, strings, chat):
key = 'texas_connected_start_state:' + str(message.from_user.id)
if redis.get(key):
await message.reply(
strings['pm_connected'].format(chat_name=chat['chat_title']))
redis.delete(key)
BUTTONS.update({'connect': 'btn_connect_start'})
@register(CommandStart(re.compile(r'btn_connect_start')), allow_kwargs=True)
@get_strings_dec('connections')
async def connect_start(message, strings, regexp=None, **kwargs):
args = message.get_args().split('_')
# In case if button have arg it will be used. # TODO: Check chat_id, parse chat nickname.
arg = args[3]
if arg.startswith('-') or arg.isdigit():
chat = await db.chat_list.find_one({'chat_id': int(arg)})
elif arg.startswith('@'):
chat = await db.chat_list.find_one({'chat_nick': arg.lower()})
else:
await message.reply(strings['cant_find_chat_use_id'])
return
from re import compile
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart
from loguru import logger
from filters.registration import IsNotRegistered, IsRegistered
from keyboards.default.menu import menu_keyboard
from loader import dp, db
from texts.emoji import simple_smile_em
from texts.registration import hello_without_code, already_registered_with_code_tx, already_registered_without_code_tx, \
hello_with_code, hello_with_code_no_ref
# @rate_limit(15)
@dp.message_handler(CommandStart(deep_link=compile(r'\d\w*')), IsRegistered(), state="*")
async def bot_start_with_code(message: types.Message):
"""
Приветствие при первом нажатии кнопки старт с пригласительным кодом.
Пользователь зарегистрирован.
"""
await message.answer(already_registered_with_code_tx.format(simple_smile_em=simple_smile_em,
name=message.from_user.full_name))
# @rate_limit(15)
@dp.message_handler(CommandStart(), IsRegistered(), state="*")
async def bot_start_with_code(message: types.Message):
"""
Приветствие при первом нажатии кнопки старт без пригласительного кода.
Пользователь зарегистрирован.
@get_strings_dec('notes')
async def note_btn(event, strings, regexp=None, **kwargs):
chat_id = int(regexp.group(2))
user_id = event.from_user.id
note_name = regexp.group(1).lower()
if not (note := await db.notes.find_one({'chat_id': chat_id, 'names': {'$in': [note_name]}})):
await event.answer(strings['no_note'])
return
with suppress(MessageCantBeDeleted):
await event.message.delete()
await get_note(event.message, db_item=note, chat_id=chat_id, send_id=user_id, rpl_id=None, event=event)
@register(CommandStart(re.compile(r'btnnotesm')), allow_kwargs=True)
@get_strings_dec('notes')
async def note_start(message, strings, regexp=None, **kwargs):
# Don't even ask what it means, mostly it workaround to support note names with _
args = re.search(r'^([a-zA-Z0-9]+)_(.*?)(-\d+)$', message.get_args())
chat_id = int(args.group(3))
user_id = message.from_user.id
note_name = args.group(2).strip("_")
if not (note := await db.notes.find_one({'chat_id': chat_id, 'names': {'$in': [note_name]}})):
await message.reply(strings['no_note'])
return
await get_note(message, db_item=note, chat_id=chat_id, send_id=user_id, rpl_id=None)
from aiogram import types
from mics import dp, bot
from models import Database
import text
import markup
from re import compile
from aiogram.dispatcher.filters.builtin import CommandStart
import datetime
import config
db = Database()
@dp.message_handler(CommandStart(), chat_id=config.admin)
async def welcome(message):
await message.answer(text=text.start_message,
reply_markup=markup.main_menu,
parse_mode='Markdown')
await db.create_table()
await db.create_table2()
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart
# from filters import IsPrivate
from loader import dp
from re import compile
# "t.me/bot?start=deep_link"
# "/start deep_link"
@dp.message_handler(CommandStart(deep_link=compile(r'\d\d\d')))
async def bot_start(message: types.Message):
deep_link_args = message.get_args()
await message.answer(f'Привет, {message.from_user.full_name}!\n'
f'Вы находитесь в личной переписке\n'
f'В вашей команде есть дип линк\n'
f'вы передали аргумент {deep_link_args}.\n')
@dp.message_handler(CommandStart(deep_link=None))
async def bot_start(message: types.Message):
bot_user = await dp.bot.get_me()
deep_link = f'http://t.me{bot_user.username}?start=123'
await message.answer(f'Привет, {message.from_user.full_name}! \n'
f'Вы находитесь в личной переписке. \n'
f'В вашей команде нет диплинка. \n'
f'Ваша диплинк сслыка - {deep_link}')
from data.items_payment import get_prices, POST_REG_SHIPPING, POST_FAST_SHIPPING, PICKUP_SHIPPING
from loader import dp, db, bot
from filters import AdminFilter
from keyboards.default.cancel_promo import cancel_menu
from keyboards.inline.promo import send_promo, change_to_inline
from keyboards.inline.promo_callback import promo_callback
from keyboards.inline.item import buy_keyboard
from utils.notify_admins import ref_notify
# TEST INVOICES ------------------
@dp.message_handler(CommandStart(deep_link="show"), state="showing")
async def show_invoice(message: types.Message, state: FSMContext):
if PROVIDER_TOKEN.split(':')[1] == 'TEST':
await message.answer('test invoice')
data = await state.get_data()
item_id = data.get("id")
item = db.select_item(id=item_id)
await bot.send_invoice(
message.chat.id,
title=item[1],
description=item[3],
provider_token=PROVIDER_TOKEN,
currency='uah',
photo_url=item[5],
photo_height=412, # !=0/None, иначе изображение не покажется
await event.answer(strings["no_note"])
return
with suppress(MessageCantBeDeleted):
await event.message.delete()
await get_note(
event.message,
db_item=note,
chat_id=chat_id,
send_id=user_id,
rpl_id=None,
event=event,
)
@register(CommandStart(re.compile(r"btnnotesm")), allow_kwargs=True)
@get_strings_dec("notes")
async def note_start(message, strings, regexp=None, **kwargs):
# Don't even ask what it means, mostly it workaround to support note names with _
args = re.search(r"^([a-zA-Z0-9]+)_(.*?)(-\d+)$", message.get_args())
chat_id = int(args.group(3))
user_id = message.from_user.id
note_name = args.group(2).strip("_")
if not (note := await db.notes.find_one({
"chat_id": chat_id,
"names": {
"$in": [note_name]
}
})):
await message.reply(strings["no_note"])
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart
import sqlite3
from loader import dp, db, bot
from data.config import super_admins
from keyboards.default import admin_keyboard
from keyboards import create_kb_coustom_main_menu
from utils import notify_someone
@dp.message_handler(CommandStart(), user_id=super_admins)
async def bot_start(message:types.Message):
user_id = message.from_user.id
text = 'Здравствуйте, Владыка!'
await bot.send_message (
chat_id=user_id,
text=text,
reply_markup=create_kb_coustom_main_menu(user_id)
)
@dp.message_handler(CommandStart())
async def bot_start(message:types.Message):
user_id = message.from_user.id
name = message.from_user.full_name
user_in_db = db.select_user(id=user_id)
from aiogram.types import Message, CallbackQuery
from aiogram.utils.emoji import emojize
from filters import IsMember
from keyboards.inline.inline_type_request_menu import inline_type_request_menu
from keyboards.main_menu import main_menu
from keyboards.inline.choice_request_buttons import choice_request
from keyboards.registration_menu import registration_menu
from keyboards.requests_menu import requests_menu
from loader import dp
from data import config, access_id
from states.task_close_inquire_state import TaskCloseInquiryState
from utils.choice_request_buttons import choice_request_buttons
@dp.message_handler(~IsMember(), CommandStart())
async def bot_start(message: Message):
await message.delete()
await message.answer(
"Необходимо зарегистрироваться, для работы в Картпэй!",
reply_markup=registration_menu,
disable_notification=True)
@dp.message_handler(~IsMember(), regexp="Зарегистрироваться")
async def registration(message: Message):
await message.delete()
await message.answer(
"{} Ваш id <b>{}</b>, сообщите его координатору Картпэй.".format(
emojize(":information_source:"), message.from_user.id))
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart
from filters.private_chat import IsPrivate
from loader import dp
from re import compile
@dp.message_handler(CommandStart(deep_link=compile(r"\d\d\d")), IsPrivate())
async def bot_start_deeplink(message: types.Message):
deep_link_args = message.get_args()
await message.answer(f'Hey, {message.from_user.full_name}!\n'
f'You are in personal correspondence.\n'
f'In you command is deep-link\n'
f'You send {deep_link_args}.\n')
@dp.message_handler(CommandStart(), IsPrivate())
async def bot_start(message: types.Message):
bot_user = await dp.bot.get_me()
deep_link = f"http://t.me/{bot_user.username}?start=123"
await message.answer(f'Hey, {message.from_user.full_name}!\n'
f'You are in personal correspondence.\n'
f'In you command there is NO deep-link\n'
f'Your deep-link - {deep_link}')
def register_manage_links_handlers(dp: Dispatcher):
dp.register_message_handler(view_links, commands="links", state="*")
dp.register_message_handler(
delete_link,
CommandStart(deep_link=re.compile(r'^del_.*$')),
state="*")
from loguru import logger
from django_project.telegrambot.usersmanage.models import User, Goods
from filters import AdminFilter
from handlers.users.purchases import purchase_start_menu
from loader import dp
from utils.database.commands.commands_goods import select_goods_by_pk
from utils.database.commands.commands_user import add_user
# @dp.message_handler(CommandStart(), AdminFilter())
# async def bot_start(message: types.Message):
# await message.answer(f"Привет admin, {message.from_user.full_name}!")
@dp.message_handler(CommandStart(deep_link=compile(r"^goods-\d+$")))
async def bot_start_buy_goods(message: types.Message, user: User):
"""Команда /start для покупки выбранного товара через inline mode"""
if not user:
await registration(message)
args = (message.get_args()).replace('goods-', '')
validation_on_exist_goods: Goods = await select_goods_by_pk(pk=int(args))
if validation_on_exist_goods:
await purchase_start_menu(message, goods=validation_on_exist_goods)
else:
logger.warning(f"{validation_on_exist_goods=}")
@dp.message_handler(CommandStart(deep_link="registration"))
return
bot_user = await bot.get_chat_member(chat_id, BOT_ID)
if 'can_restrict_members' not in bot_user or bot_user[
'can_restrict_members'] is False:
return
key = 'leave_silent:' + str(chat_id)
redis.set(key, user_id)
await unmute_user(chat_id, user_id)
await kick_user(chat_id, user_id)
await tbot.delete_messages(chat_id, [message_id, wlkm_msg_id])
@register(CommandStart(re.compile(r'welcome_security')), allow_kwargs=True)
@get_strings_dec('greetings')
async def welcome_security_handler_pm(message,
strings,
regexp=None,
state=None,
**kwargs):
args = message.get_args().split('_')
chat_id = int(args[2])
user_id = message.from_user.id
async with state.proxy() as data:
data['chat_id'] = chat_id
data['msg_id'] = int(args[4])
if not message.from_user.id == int(args[3]):
from aiogram import types
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.builtin import CommandStart
from data.config import admins
from filters import IsUser
from keyboards.default.admin_keyboard import admin_keyboard
from keyboards.default.get_menu_keyboard import user_menu_keyboard
from keyboards.inline.enter_code_keyboard import enter_code_keyboard
from loader import dp
from utils.db_api import redis_commands, db_commands
@dp.message_handler(CommandStart(), user_id=admins)
async def admin_bot_start(message: types.Message, state: FSMContext):
await state.finish()
await message.answer(
f'Приветcтвую, дрогой админ {message.from_user.full_name}!',
reply_markup=admin_keyboard)
if not await redis_commands.is_user(message.from_user.id):
user = message.from_user
await db_commands.add_user(
user_id=user.id,
username=user.username,
full_name=user.full_name,
)
await redis_commands.set_new_user(message.from_user.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)
@dp.callback_query_handler(help_btn_cp.filter())
async def get_help_button_callback(query, callback_data=False, **kwargs):
message = query.message
module = callback_data['module']
data = callback_data['btn']
chat_id = query.message.chat.id
lang = get_chat_lang(chat_id)
text = ""
text += LANGUAGES[lang]["HELPS"][module][data]
buttons = InlineKeyboardMarkup().add(InlineKeyboardButton("Back", callback_data='get_help'))
await message.edit_text(text, reply_markup=buttons)
@dp.message_handler(CommandStart('help'))
async def help_start(message):
text, buttons = get_help(message.chat.id)
await message.answer(text, reply_markup=buttons)
from loguru import logger
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart
from app.misc import dp
from app.models.user import User
from app.handlers.user.register import command_register
from app.handlers.user.link_mc_account import command_link
from app.utils.about_server import info_buttons
@dp.message_handler(CommandStart("register"))
async def command_start(message: types.Message, user: User):
return await command_register(message, user)
@dp.message_handler(CommandStart("link"))
async def command_start(message: types.Message, user: User):
return await command_link(message, user)
@dp.message_handler(CommandStart())
async def command_start(message: types.Message, user: User):
logger.info("User {user_id} start conversation {chat_id}.",
user_id=message.from_user.id,
chat_id=message.chat.id)
if types.ChatType.is_private(message):
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart
from main import dispatcher
@dispatcher.message_handler(CommandStart())
async def process_start(message: types.Message):
await message.answer(f'Привет, {message.from_user.full_name}!\n '
'Я помогу тебе контролировать дедлайны!')
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart
from filters import GroupFilter
from loader import dp
@dp.message_handler(CommandStart(), GroupFilter())
async def bot_start(message: types.Message):
await message.answer(f"Я работаю! Скинь войс!")
from loader import dp, bot
from utils.json_actions.get_films import get_films_json
from ast import literal_eval
from datetime import datetime
def get_name_film(film_id, films):
for film in films:
if films[film]['_id'] == film_id:
return film
@dp.message_handler(IsUserConfirmed(), CommandStart())
async def bot_start(message: Message, mode='text'):
films = get_films_json()
choice_films = generate_all_films(films)
text = '*Все фильмы в Воронеже:*\n\n'
for film in films:
text += f"{film} - ( Рейтинг: *{films[film]['rating'][:3]}* )\n"
if mode == 'text':
return await message.answer(text, reply_markup=choice_films, parse_mode="MARKDOWN")
elif mode == 'edit':
return await bot.edit_message_text(text=text, reply_markup=choice_films, parse_mode="MARKDOWN", message_id=message.message_id, chat_id=message.chat.id)
elif mode == 'posters':
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart
from filters import IsPrivate
from loader import dp
from utils.misc import rate_limit
from utils.db_api import User
import logging
@rate_limit(limit=10)
@dp.message_handler(CommandStart(), IsPrivate())
async def bot_start(message: types.Message, user: User):
await message.answer(f'Привет, {message.from_user.full_name}!\n'
f'Ваши данные: {user.__dict__}')
# Не попадает в error handler
try:
await message.answer("Неверное закрытие <b>тега<b>")
except Exception as err:
await message.answer(f"Ошибка: {err}")
# Попадает в error handler
# 1/0
await message.answer("Нет такого <kek>тега</kek>")
logging.info("Ошибка, бот не упал!")
import re
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart
from data.config import referral_reward
from data.mesages_config import WELCOME, NO_REF_CODE_FOUND, REF_CODE_ALREADY_ENTERED, YOU_USE_YOUR_LINK
from keyboards.default import menu
from loader import dp, db
@dp.message_handler(CommandStart(deep_link=re.compile(r'^[0-9]{4,15}$')))
async def start_deeplink(message: types.Message):
code = int(message.get_args())
user_id = message.from_user.id
user_status = (await db.check_user(user_id))[0].get('count')
if (await db.check_user(code))[0].get('count') == 1 and user_status == 0:
await db.add_user(user_id, True)
await db.add_earnings_for_referrals(code, referral_reward)
await message.answer(WELCOME, reply_markup=menu)
elif (await db.check_user(code))[0].get('count') == 0 and user_status == 0:
await message.answer(NO_REF_CODE_FOUND, reply_markup=menu)
await db.add_user(user_id, False)
elif (await db.check_user_for_referal(user_id))[0].get('count') == 0:
await message.answer(REF_CODE_ALREADY_ENTERED, reply_markup=menu)
elif (await db.check_user_for_referal(user_id))[0].get('count') == 1 and code != user_id:
await db.add_earnings_for_referrals(code, referral_reward)
await db.set_invited_true(message.from_user.id)
args = message.get_args()
if not args:
await message.reply(
"Low Voice Bot helps send *private ️messages* in public groups.",
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True,
reply_markup=InlineKeyboardMarkup(inline_keyboard=[[
InlineKeyboardButton("Start", switch_inline_query="")
]]),
)
else:
raise SkipHandler
@dispatcher.message_handler(
CommandStart(re.compile(r"SAVE\_(?P<whisper_id>.+)")))
async def start_save_handler(message: types.Message, deep_link: re.Match):
logger.debug(f"start_save_handler:{deep_link}")
try:
try:
whisper_id = deep_link.group("whisper_id")
except IndexError:
raise ReadableException("❌ Malformed arguments")
whisper = whispers.get(whisper_id)
if whisper is None:
logger.debug(f"start_handler:Invalid whisper id: {whisper_id}")
raise ReadableException(
"⏲️🔔/❌ The message is expired or non-existent.")
if (message.from_user.username != whisper.recipient
and message.from_user != whisper.sender):
raise ReadableException(
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart
from aiogram.utils.deep_linking import get_start_link
from src.filters import IsPrivate
from re import compile
from src.loader import dp
from loguru import logger
@dp.message_handler(CommandStart(deep_link=compile(r"\d\d\d"), encoded=True),
IsPrivate())
async def bot_start_deeplink(message: types.Message):
deep_link_args = message.get_args()
await message.answer(f"Привет, {message.from_user.full_name}!\n"
f"Вы находитесь в личной переписке. \n"
f"В вашей команде есть диплинк. \n"
f"Вы передали аргумент {deep_link_args}. \n")
logger.info(
f"User <{message.from_user.full_name}[{message.from_user.id}]> started with deeplink"
)
@dp.message_handler(CommandStart(deep_link=None), IsPrivate())
async def bot_start_without_deeplink(message: types.Message):
deep_link = await get_start_link("123", encode=True)
await message.answer(f"Привет, {message.from_user.full_name}!\n"
f"Вы находитесь в личной переписке. \n"
called_user_id = message.from_user.id
url = f'https://t.me/{BOT_USERNAME}?start=ws_{chat_id}_{called_user_id}_{message.message.message_id}'
if not called_user_id == real_user_id:
# The persons which are muted before wont have their signatures registered on cache
if not redis.exists(
f"welcome_security_users:{called_user_id}:{chat_id}"):
await message.answer(strings['not_allowed'], show_alert=True)
return
else:
# For those who lost their buttons
url = f'https://t.me/{BOT_USERNAME}?start=ws_{chat_id}_{called_user_id}_{message.message.message_id}_0'
await message.answer(url=url)
@register(CommandStart(re.compile(r'ws_')), allow_kwargs=True)
@get_strings_dec('greetings')
async def welcome_security_handler_pm(message: Message,
strings,
regexp=None,
state=None,
**kwargs):
args = message.get_args().split('_')
chat_id = int(args[1])
async with state.proxy() as data:
data['chat_id'] = chat_id
data['msg_id'] = int(args[3])
data['to_delete'] = bool(int(args[4])) if len(args) > 4 else True
db_item = await get_greetings_data(chat_id)
import asyncpg
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart, Text
from keyboards.default import who_you_are
from loader import dp
from utils.db_api import quick_commands as commands
from aiogram.dispatcher import FSMContext
from states.botStates import StatesOfBot
@dp.message_handler(CommandStart(), state=None)
async def bot_start(message: types.Message, state: FSMContext):
name = message.from_user.full_name
try:
await commands.add_user(id=message.from_user.id, name=name)
except asyncpg.exceptions.UniqueViolationError:
pass
# count = await commands.count_users()
await message.answer(
f'Привет, {message.from_user.full_name}!\n'
"Кем вы являетесь?",
reply_markup=who_you_are)
await StatesOfBot.start_state.set()
# await StatesOfBot.next()
# -*- coding: utf-8 -*-
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart
from loader import dp
from sql.sql_commands import user_add_for_db
@dp.message_handler(CommandStart())
async def start(message: types.Message):
await message.answer(
f'Привет, {message.from_user.full_name}.\nЭто бот в котором ты можешь купить и прокачать свой собственный бульдозер и соревноваться его мощьностями с другими игроками\nВсе комманды: /commands'
)
user_add_for_db(chat_id=message.from_user.id)
import re
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart
from handlers.users import show_main_menu
from loader import dp
@dp.message_handler(CommandStart(deep_link=None))
async def bot_start(message: types.Message):
# Get user full name
username: str = message.from_user.username
full_name: str = message.from_user.full_name
# Get user ID
user_id: int = message.from_user.id
# Show main menu
await message.answer(text=f'Привет, {full_name}!')
await show_main_menu(message)
