'$in': [note_name]
}
})):
await event.answer(strings['no_note'])
return
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):
args = message.get_args().split('_')
chat_id = int(args[2])
user_id = message.from_user.id
note_name = args[1].lower()
if not (note := await db.notes_v2.find_one({
'chat_id': chat_id,
'names': {
'$in': [note_name]
}
})):
await message.reply(strings['no_note'])
return
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 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, иначе изображение не покажется
# @dp.message_handler(IsMember(), CommandStart(deep_link = re.compile('.+?')))
# async def param_product(message: types.Message):
# """Product's shopping"""
# item_id = message.get_args()
# print('param_product -> item_id={}'.format(item_id))
# product = await get_product_by_itemid(int(item_id))
# await message.answer_photo(photo = product.photo,
# caption = f'{hbold(product.name)}\n'
# f'{hitalic(product.description)}\n\nЦена = '
# f'{hbold(product.price)}',
# reply_markup = choice_buy(item_id))
@dp.message_handler(IsNotMember(), CommandStart())
async def bot_start(message: types.Message):
"""Referral's operation"""
args = message.get_args()
print('args = {}'.format(args))
referral = None
if args and args != 'not_user':
referral = decode_payload(args)
print('referral = {}'.format(referral))
if not referral or args == 'not_user':
text = ['Чтобы использовать этого бота введите код приглашения, либо пройдите по реферальной ссылке.',
'Введите команду /invite для ввода кода приглашения:']
# \nРеферальная ссылка https://t.me/{bot_username}?start={chat_id}
await message.answer('\n'.join(text))
# await message.answer(text = 'Введите команду /invite для ввода кода приглашения:')
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.filters.builtin import CommandStart, ChatType
from app.loader import dp
@dp.message_handler(CommandStart(), ChatType.PRIVATE)
async def bot_start(message: types.Message):
await message.answer(f'Привет, {message.from_user.full_name}!')
import sqlite3
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart
from loader import dp, db
@dp.message_handler(CommandStart())
async def bot_start(message: types.Message):
name = message .from_user.full_name
try:
db.add_user(id=message.from_user.id, name=name)
except sqlite3.IntegrityError as err:
print(err)
count_users = db.count_users()[0]
await message.answer(
"\n".join([
f'Привет, {message.from_user.full_name}!',
'Ты был занесен в базу',
f'В базе <b>{count_users}</b> пользователей',
])
)
# await message.answer(f'Привет, {message.from_user.full_name}!')
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"))
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 keyboards import inline
logger = logging.getLogger(__name__)
class StartState(StatesGroup):
intro = State()
no_person_in_db = State()
show_profile_or_stats = State()
showing_person_data = State()
showing_statistics = State()
edit_profile = State()
# при нажатии старт
@dp.message_handler(CommandStart(), IsPrivate())
async def bot_start_without_deeplink(message: types.Message,
state: FSMContext):
logger.info(
f'Пользователь {message.from_user.full_name} (ID: {message.from_user.id}) нажал команду СТАРТ'
)
cod_chat = await dp.bot.get_chat(chat_id=COD_CHAT_ID)
text = [
'Данный бот написан для предоставления пользователям информации по своей статистике в игре '
f'CALL OF DUTY MW 2019/CW/Warzone и упрощения коммуникации участников тематической группы '
f'<a href="{cod_chat.invite_link}">{cod_chat.full_name}</a>', '',
'<b>Для отображения инфы жмакай /me</b>', '',
'Справка по основным командам: /help', '', 'автор: @MaN1Le'
]
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart, Command
from aiogram.types import ReplyKeyboardRemove
from keyboards.default import yes_markup
from loader import dp
from states import PortfolioStates
@dp.message_handler(CommandStart("start"))
async def bot_start(message: types.Message):
await message.answer(f'Добрый день, {message.from_user.full_name}.\n\n'
'Вы вступили в переписку с робоэдвайзером, который помогает осуществлять ребалансировку'
' инвестиционного портфеля, состоящего из ценных бумаг\n\n'
'Чат-бот использует модельные данные по акциям из {источник} ***\n\n'
'По вопросам, связанным с робоэвдайзером, можно обращаться'
' к основателю проекта @elais_loladze')
#await message.answer("Перейти к робоэдвайзеру?", reply_markup=yes_markup)
await PortfolioStates.Set_Budget.set()
#await message.answer(f'Привет, {message.from_user.full_name}!')
@dp.message_handler(Command("start"))
async def bot_start(message: types.Message):
await message.answer(f'Добрый день, {message.from_user.full_name}.\n\n'
'Вы вступили в переписку с робоэдвайзером, который помогает осуществлять ребалансировку'
' инвестиционного портфеля, состоящего из ценных бумаг\n\n'
'Чат-бот использует модельные данные по акциям из {источник} ***\n\n'
'По вопросам, связанным с робоэвдайзером, можно обращаться'
' к основателю проекта @elais_loladze')
#await message.answer("Перейти к робоэдвайзеру?", reply_markup=yes_markup)
import re
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart
from keyboards.default.home import home
from loader import dp
@dp.message_handler(CommandStart(deep_link=re.compile(r'^[0-9]{3,15}$')))
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'Ваш рефер - id{deep_link_args}\n\n'
'<b>Добро пожаловать в наш скромный магаин</b>',
reply_markup=home)
@dp.message_handler(CommandStart())
async def bot_start(message: types.Message):
await message.answer(f"Привет, {message.from_user.full_name}!",
reply_markup=home)
from re import compile
from aiogram import types
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.builtin import CommandStart
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from loader import dp, db
from states.referal_start import ReferalStart
@dp.message_handler(CommandStart(deep_link='connect_user'))
async def connect_user(message: types.Message):
"""Инструкции пользователю, пришедшего из инлайн режима"""
user_id = int(message.from_user.id)
refr = await db.select_all_user_id()
name = message.from_user.full_name
bot_user = await dp.bot.get_me()
if user_id in refr:
await message.answer(
'Вы уже зарегистрированы в боте и можете начать поиск товаров или приглашение друзей\n'
f' http://t.me/{bot_user.username}?start={user_id}',
reply_markup=InlineKeyboardMarkup(inline_keyboard=[[
InlineKeyboardButton(text='Начать поиск товаров',
switch_inline_query_current_chat='')
]]))
else:
await message.answer(
f'Привет, {name}!\n'
f'Для пользования ботом Вы должны ввести пригласительный код\n'
f'Пожалуйста, ведите реферальный код или перейдите по действующей ссылке'
from aiogram import types
from aiogram.dispatcher.filters.builtin import CommandStart
from aiogram.dispatcher.handler import CancelHandler
from filters.StartFilters import IsNotRegistered
from keyboards.default.start_keyboards import generate_start_keyboard
from loader import dp
from states.GeneralState import StartState
from states.auth_state import AuthState
from utils.db_api.fast_commands import check_promo
@dp.message_handler(IsNotRegistered(),
CommandStart(),
state=AuthState.check_code)
@dp.message_handler(IsNotRegistered(), CommandStart())
async def check_auth(message: types.Message):
await message.answer(
text=
'Пожалуйста, введите специальный код доступа, чтобы пользоваться функциями бота.'
)
await AuthState.check_code.set()
@dp.message_handler(state=AuthState.check_code)
async def handle_code(message: types.Message):
answer = await check_promo(message)
if not answer:
raise CancelHandler()
await message.answer(
'Вы успешно зарегистрировались в боте используя код доступа',
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 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}')
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)
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 aiogram.types import CallbackQuery, Message
from states.states import Menu
from utils.db_api import db_commands
from loader import dp, _, bot
from data.config import admins
db = db_commands.DBCommands()
@dp.message_handler(CommandStart(), state="*")
async def register_user(message: Message, state: FSMContext):
await state.reset_state()
chat_id = message.from_user.id
referral = message.get_args()
user_exists = await db.user_exists(chat_id)
if user_exists:
await show_menu(message)
return
user = await db.add_new_user(referral=referral)
id = user.id
bot_username = (await bot.me).username
bot_link = f"https://t.me/{bot_username}?start={id}"
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)
@register(cmds='start', only_pm=True)
@get_strings_dec('connections')
@chat_connection()
async def connected_start_state(message, strings, chat):
key = 'hitsuki_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 aiogram.types import Message
from aiogram.dispatcher.filters.builtin import CommandStart
from loader import dp
from states.registration import RegistrationStates
from aiogram.utils.markdown import hbold, hitalic
#on first start, user is set to register his group
# handler on first start from inline mode(with deeplink)
@dp.message_handler(CommandStart(deep_link="connect_user_from_inline_mode"))
async def bot_first_start(message: Message):
await RegistrationStates.RegisterGroupFromInline.set()
await message.answer(
text=f"Привет, {message.from_user.full_name}!\n"
f"Вижу, ты уже хочешь воспользоваться inline mode?\n"
f"Для работы мне нужно зарегистрировать тебя.\n\n"
f"Пожалуйста, напиши мне номер своей группы.\n"
f"Можешь писать заглавными/строчными {hbold('русскими')} буквами, '-' ставить {hbold('не обязательно')}.\n\n"
f"Например, я пойму {hitalic('любой')} из этих вариантов: 3а1, 3А1, 3-а-1."
)
# handler on first start from bot
@dp.message_handler(CommandStart())
async def bot_first_start(message: Message):
await RegistrationStates.RegisterGroup.set()
await message.answer(
text=f"Привет, {message.from_user.full_name}!\n"
