async def hello(msg: types.message):
user = f"tg://user?id={msg.new_chat_members[0].id}"
user1 = hlink(f"{msg.new_chat_members[0].full_name}", user)
rule_link = hlink("правилами", "https://t.me/gotbs/559")
mem = await bot.get_chat_member(msg.chat.id, msg.new_chat_members[0].id)
rule_msg = 0
if mem.can_send_messages is False:
await msg.answer(f"""🗡Приветствую, {user1}️!
Добро пожаловать!""",
disable_web_page_preview=True,
parse_mode='HTML')
if msg.chat.id == -1001279094011:
rule_msg = await msg.answer(
f"<b>Вступая в чат, вы автоматически соглашаетесь с</b> {rule_link}<b>!</b>",
disable_web_page_preview=True,
parse_mode='HTML')
await asyncio.sleep(30)
await bot.delete_message(msg.chat.id, msg.message_id + 1)
if msg.chat.id == -1001279094011:
await bot.delete_message(msg.chat.id, rule_msg.message_id)
else:
try:
await bot.restrict_chat_member(msg.chat.id,
msg.new_chat_members[0].id,
can_send_messages=False,
can_send_media_messages=False,
can_send_other_messages=False)
accept = InlineKeyboardButton("Я человек", callback_data="accept")
key_board = InlineKeyboardMarkup(row_width=1).add(accept)
await msg.answer(f"""🗡Приветствую, {user1}️!
Добро пожаловать!
Пока ты не можешь писать в группе, но не волнуйся, просто нажми на кнопку и ты сможешь писать!""",
disable_web_page_preview=True,
parse_mode='HTML',
reply_markup=key_board)
if msg.chat.id == -1001279094011:
rule_msg = await msg.answer(
f"<b>Вступая в чат, вы автоматически соглашаетесь с</b> "
f"{rule_link}<b>!</b>",
disable_web_page_preview=True,
parse_mode='HTML')
chat_id = msg.chat.id
us_id = msg.new_chat_members[0].id
await bot.delete_message(msg.chat.id, msg.message_id)
await asyncio.sleep(30)
mem = await bot.get_chat_member(chat_id, us_id)
if mem.can_send_messages is False:
await bot.kick_chat_member(chat_id, us_id)
await bot.unban_chat_member(chat_id, us_id)
await bot.delete_message(msg.chat.id, msg.message_id + 1)
if msg.chat.id == -1001279094011:
await bot.delete_message(msg.chat.id, rule_msg.message_id)
except NotEnoughRightsToRestrict:
await msg.answer(f"""🗡Приветствую, {user1}️!
Добро пожаловать!""",
disable_web_page_preview=True,
parse_mode='HTML')
async def weblink(self):
for chat_id in self.domain_users:
print(chat_id, self.message_obj.title, 'type weblink')
self.message_obj.message += '\n' + hlink(self.message_obj.media[1],
self.message_obj.media[0])
await bot.send_message(chat_id=chat_id,
text=self.message_obj.message[0:3900] +
hlink('...', self.message_obj.link)
if len(self.message_obj.message) > 4096 else
self.message_obj.message,
parse_mode=ParseMode.HTML,
reply_markup=await keyboards.post_keyboard(
self.message_obj.title,
self.message_obj.link))
async def hello(msg: types.message):
user = f"tg://user?id={msg.new_chat_members[0].id}"
user1 = hlink(f"{msg.new_chat_members[0].full_name}", user)
gip = hlink("правилами", "https://telegra.ph/Prpvila-G%C3%98T-Mafia-07-24")
chat = hlink("Ссылка на чат", "https://t.me/mafgot")
chat1 = hlink("Чат Family GØT", "https://t.me/bsgot")
await msg.answer(f"""🗡Приветствую, {user1}️!
🔫Ты попал в чат любителей игры
Мафия,располагайся)
‼️Перед началом игры,ознокомься с базовыми знаниями игры,а также нашими правилами {gip}‼️
🔫{chat}
🐉{chat1}""",
disable_web_page_preview=True,
parse_mode='HTML')
async def from_dict(data: Dict[str, Any]) -> 'Feedback':
corrector_comment = (data['comment'] or '').replace("<", "<")
peer_comment = (data['feedback'] or '').replace("<", "<")
if corrector_comment and peer_comment:
mark = data['final_mark']
team = data['team']['name']
peer = 'SYSTEM'
if data['feedbacks'][0]['user'] is not None:
peer_login = data['feedbacks'][0]['user']['login']
peer_link = f'https://profile.intra.42.fr/users/{peer_login}'
peer = hlink(title=peer_login, url=peer_link)
rating = data['feedbacks'][0]['rating']
final_mark = data['team']['final_mark']
project_id = data['team']['project_id']
project = await Savers.get_project(
project_id=project_id,
project_gitlab_path=data['team']['project_gitlab_path'])
return Feedback(corrector_comment=corrector_comment,
mark=mark,
team=team,
project=project.name,
peer=peer,
peer_comment=peer_comment,
rating=rating,
final_mark=final_mark)
async def послать_медиа_группу(диспетчер):
"""
Посылаем медиагруппу из телеграм бота.
Параметры
----------
диспетчер : Диспетчер класса Dispatcher, отвечает за маршрутизацию
сообщений, не имеет значения для работы данной функции
"""
# Создаём "контейнер" для наших медиа, т.е. изображений
media = types.MediaGroup()
# Получаем список текущих изображений в указанной папке
все_изображения = получить_название_всех_изображений()
текст_ссылки = 'читать дальше ...'
ссылка = ''
for позиция, путь_к_изображению in enumerate(все_изображения, start=1):
# Добавляем описание только к последней фотографии.
if позиция == len(все_изображения):
описание = "Описание для изображения. " + hlink(
текст_ссылки, ссылка)
else:
описание = None
# По очереди добавляем все изображения и директории
# К нашему контйнеру.
# При этом добавляем описание только к последней фотографии,
# А у всех остальных описание = None
media.attach_photo(types.InputFile(путь_к_изображению), описание)
try:
# Пытаемся послать медиагруппу в указанный chat_id
await bot.send_media_group(chat_id='-1001188248012', media=media)
except Exception as ошибка:
# В случае ошибки, сообщаем об этом пользователю и
# И прерываем выполнение скрипта командой
# raise
print("Во время отправки медиагруппы произошла ошибка")
raise ошибка
# При успешной отправке сообщений
# Выводим на экран полезное сообщение
# И завершаем работу скрипта.
print("Отправка сообщений завершена.")
sys.exit(0)
def screen_name(user: [dict, types.User], tag=True) -> str:
if isinstance(user, types.User):
user = user.to_python()
title = user['first_name'] + (f" {user['last_name']}"
if user.get('last_name') else '')
if tag:
return hlink(title, f"tg://user?id={user['id']}")
else:
return title
async def report_user(message: types.Message):
"""Отправляет жалобу на пользователя админам"""
reply = message.reply_to_message
# Если юзер репортит на сообщение из канала, то пропускаем это
if reply.is_automatic_forward is True:
await message.delete()
return
# Проверка на то что реплай сообщение написано от имени канала
if reply.sender_chat:
mention = reply.sender_chat.title
else:
mention = reply.from_user.get_mention()
chat_id = message.chat.id
await message.answer(
f"Репорт на пользователя {mention} успешно отправлен.\n"
"Администрация предпримет все необходимые меры")
chat_admins = db.select_all_chat_admins(chat_id)
if not chat_admins:
# На всякий случай что бы не было спама
data = await dp.storage.get_data(chat=chat_id)
if data.get('last_get_admins_time', 0) < time.time():
await dp.storage.update_data(
chat=chat_id,
data={'last_get_admins_time': time.time() + 3600})
admins = await dp.bot.get_chat_administrators(chat_id)
for admin in admins:
if admin.user.is_bot is False:
db.add_chat_admin(chat_id, admin.user.id)
chat_admins = db.select_all_chat_admins(chat_id)
for admin in chat_admins:
admin_id = admin[0]
try:
await dp.bot.send_message(
chat_id=admin_id,
text=f"Кинут репорт на пользователя {mention} "
"за следующее " +
hlink("сообщение", message.reply_to_message.url))
await asyncio.sleep(0.05)
except (exceptions.BotBlocked, exceptions.UserDeactivated,
exceptions.CantTalkWithBots,
exceptions.CantInitiateConversation):
db.del_chat_admin(chat_id, admin_id)
except Exception as err:
logger.exception(
"Не предвиденное исключение при рассылке сообщений админам чата при отправке репорта."
)
logger.exception(err)
async def send_report(msg: types.message):
if msg.reply_to_message is None:
await msg.answer("Команда должна являться ответом на сообщение!")
else:
await msg.answer("Я отправил жалобу администраторам!")
admins = await bot.get_chat_administrators(msg.chat.id)
chat_link = f"tg://chat?id={msg.chat.id}"
chat_high_link = hlink(f"{msg.chat.title}", chat_link)
user1_link = f"tg://user?id={msg.reply_to_message.from_user.id}"
user1 = hlink(f"{msg.reply_to_message.from_user.first_name}",
user1_link)
user2_link = f"tg://user?id={msg.from_user.id}"
user2 = hlink(f"{msg.from_user.first_name}", user2_link)
message_link = f"https://t.me/{msg.chat.username}/{msg.reply_to_message.message_id}"
message = hlink("Ссылка на сообщение", message_link)
mute1 = InlineKeyboardButton("Замутить нарушителя на час",
callback_data="m1")
mute2 = InlineKeyboardButton("Замутить за ложный репорт на час",
callback_data="m2")
del_message = InlineKeyboardButton("Удалить сообщение",
callback_data="d")
ban_user = InlineKeyboardButton("Забанить нарушителя",
callback_data="b")
keyboard = InlineKeyboardMarkup(row_width=1).add(
mute1, mute2, del_message, ban_user)
for a in admins:
if (((a.can_delete_messages is True) and
(a.can_restrict_members is True))
or a.status == "creator") and a.user.is_bot is False:
try:
await bot.send_message(
chat_id=a.user.id,
text=f"""<b>Внимание! Report из </b>{chat_high_link}
<b>Жалоба на:</b> {user1}
<b>От:</b> {user2}
{message}
<b>Текст сообщения:</b> {msg.reply_to_message.text}
<b>Что делать с нарушителем?</b>""",
parse_mode="HTML",
reply_markup=keyboard)
except:
pass
async def check_explicit(self, message: types.Message):
from explicit import find_explicit
text = message.text
chat = message.chat
user = message.from_user
# message without text skip
if not text:
return
# is explicit found?
result = await find_explicit(text)
if not result:
await self.cb.register_message(user_id=user.id,
intent='normal message')
return
logger.info(f'Found explicit in message: {text}')
await self.cb.register_message(user_id=user.id,
intent='explicit message')
# let's delete bad message
await self.delete_message(message)
# notify user
try:
jail[user.id] += 1
except KeyError:
jail[user.id] = 1
user_link = md.hlink(user.full_name, f'tg://user?id={user.id}')
if jail.get(user.id) <= 2:
text = _('Ай-ай-ай, {user_link}!', user_link=user_link)
await self.say(chat.id, text)
return
if 2 < jail.get(user.id) < 5:
text = _('{user_link}, я же тебя предупреждал... Иди молчать.',
user_link=user_link)
await self.say(chat.id, text)
await aio.sleep(1)
await self.restrict_user(chat.id, user.id,
5 * 60 * jail.get(user.id))
return
if jail.get(user.id) >= 5:
text = _('{user_link}, я же тебя предупреждал... Иди в бан.',
user_link=user_link)
await self.say(chat.id, text)
await aio.sleep(1)
await self.kick(chat.id, user.id, 24 * 60 * 60)
jail[user.id] = 3
return
async def info_about_college(callback: CallbackQuery):
await bot.edit_message_text(message_id=callback.message.message_id,
chat_id=callback.message.chat.id,
text=address,
reply_markup=cancel)
await bot.send_message(
callback.message.chat.id,
text=hlink(
'Location',
'https://www.google.com/maps/place/JIC/@42.9180431,71.3731849,15z/'
'data=!4m5!3m4!1s0x0:0xf7306df39a933728!8m2!3d42.'
'9180431!4d71.3731849'))
def Check_for_new_post():
global last_news
url = 'http://mignews.com/mobile'
page = requests.get(url)
soup = BeautifulSoup(page.text, "html.parser")
if last_news != soup.findAll('span', class_='time2 time3')[0]:
link = soup.findAll('a', class_='lenta')[0]
text = link.text
link = 'http://mignews.com' + link.get('href')
last_news = soup.findAll('span', class_='time2 time3')[0]
return hlink(text, link)
async def cmd_start(message: types.Message, user: User):
logger.info("User {user} start conversation with bot",
user=message.from_user.id)
await message.answer(
_("Hello, {user}.\n"
"Send /help if you want to read my commands list "
"and also you can change language by sending /settings command.\n"
"My source code: {source_url}").format(
user=hbold(message.from_user.full_name),
source_url=hlink("GitHub", "https://github.com/aiogram/bot"),
))
await user.update(start_conversation=True).apply()
async def send_invoice(message, state: FSMContext):
payment = Payment(amount=amount)
payment.create()
await call.message.answer("\n".join([
f"Оплатите не менее {amount:.2f} по номеру телефона или по адресу", "",
hlink(config.WALLET_QIWI, url=payment.invoice),
"И обязательно укажите ID платежа:",
hcode(payment.id)
]),
reply_markup=paid_keyboard)
await state.set_state("qiwi")
await state.update_data(payment=payment)
def NewsFromMeduza(N):
ans = requests.get(
'https://meduza.io/api/v3/search?chrono=news&page=0&per_page=10&locale=ru')
ans = ans.json()
news = []
for i in ans['documents']:
news.append(hlink(ans['documents'][i]['title'],
'https://meduza.io/' + ans['documents'][i]['url']))
# for i in range(10):
# print(news[i], urls[i], sep='\n', end='\n\n')
return news[:N]
async def process_callback_get_schedule(callback_query: types.CallbackQuery):
buttons = buttons_constructor.init_inline(buttons=dialog.command_buttons)
await bot.answer_callback_query(callback_query.id)
reply_text = [md.text(f"{get_today_date()}")]
await bot.send_chat_action(callback_query.from_user.id, "Typing")
user = await get_or_create_user(
telegram_id=callback_query.from_user.id,
first_name=callback_query.from_user.first_name,
)
session = await check_for_session(
bot=bot, user=user, buttons=buttons, telegram_id=callback_query.from_user.id
)
if session is None:
return
site_events = SiteEvents(login_session=session)
schedule = site_events.get_todays_schedule()
if schedule is None:
await bot.send_message(
callback_query.from_user.id, "No schedule", reply_markup=buttons
)
return
for subj in schedule:
reply_text.append(
md.text(
dialog.schedule_text.format(
time=subj["time"],
name=subj["name"],
subject=subj["subject"],
lecture=subj["lecture"],
format=subj["format"],
link=md.hlink("Lesson url", subj["link"])
if subj["link"] is not None
else "Has no distance lesson link",
)
)
)
reply_text = md.text(*reply_text, sep="\n")
await bot.send_message(
callback_query.from_user.id,
reply_text,
reply_markup=buttons,
parse_mode=types.message.ParseMode.HTML,
)
def NewsFrom_MigNewsCom(N):
url = 'http://mignews.com/mobile'
page = requests.get(url)
filteredNews, allNews = [], []
soup = BeautifulSoup(page.text, "html.parser")
allNews = soup.findAll('a', class_='lenta')
allLinks = []
for link in soup.findAll('a', class_='lenta'):
allLinks.append('http://mignews.com' + link.get('href'))
for num, data in enumerate(allNews, start=0):
if data.find('span', class_='time2'):
filteredNews.append(hlink(data.text, allLinks[num]))
return filteredNews[:N]
async def video(self):
try:
for chat_id in self.domain_users:
print(chat_id, self.message_obj.title, 'type video')
await bot.send_video(chat_id=chat_id,
video=self.message_obj.media,
caption=self.message_obj.message[0:900] +
hlink('...', self.message_obj.link)
if len(self.message_obj.message) > 1024
else self.message_obj.message,
parse_mode=ParseMode.HTML,
reply_markup=await
keyboards.post_keyboard(
self.message_obj.title,
self.message_obj.link))
except InvalidHTTPUrlContent:
await self.weblink()
async def create_invoice_qiwi(call: CallbackQuery, state: FSMContext):
await call.answer(cache_time=60)
item_id = call.data.split(':')[-1]
item_id = int(item_id) - 1
item = items[item_id]
amount = item.price
payment = Payment(amount=amount)
payment.create()
await call.message.answer("\n".join([
f"Pay {amount:.2f} by phone number or address", "",
hlink(config.QIWI_WALLET, url=payment.invoice), "Your payment ID",
hcode(payment.id)
]),
reply_markup=paid_button)
await state.set_state("q_pay")
await state.update_data(payment=payment)
async def create_invoice(call: CallbackQuery, state: FSMContext):
await call.answer(cache_time=60)
item_id = int(call.data.split(":")[-1]) - 1
item = Maps[0]
amount = item.price
payment = PaymentForQiwi(amount=amount)
payment.create()
await call.message.answer("\n".join([
f"Оплатите не менее {amount:.1f} по номеру телефона или по адресу",
hlink(WALLET_QIWI, url=payment.invoice),
"Обязательно укажите ID платежа",
hcode(payment.id)
]),
reply_markup=paid_keyboard)
await state.set_state("qiwi")
await state.update_data(payment=payment)
def get_content(html):
soup = BeautifulSoup(html, "html.parser")
if soup.find("div", class_="span8 offset2") is None:
command_html = soup.find("div", id="command")
command_info = command_html.text.split()
command_info[0] = command_info[0][0:len(command_info[0])-3]
command_link = command_html.a["href"]
command_link = hlink("Manual", command_link)
command_result = " ".join(command_info) + "\n " + command_link
return command_result
else:
return "Nothing found"
async def watch_get(m: types.Message, user: dict, chat: dict):
get = await bot.send_message(
m.chat.id, text=hbold('🎉 GET /hw/ 4️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣'))
try:
await bot.pin_chat_message(m.chat.id,
get.message_id,
disable_notification=False)
except:
pass
await bot.send_message(
94026383,
text='GET @{} {}'.format(
m.chat.username,
hlink(str(get.message_id),
'https://t.me/{}/{}'.format(m.chat.username,
get.message_id))))
SkipHandler()
async def image(self):
try:
for chat_id in self.domain_users:
print(chat_id, self.message_obj.title, 'type image')
await bot.send_photo(chat_id=chat_id,
photo=self.message_obj.media,
caption=self.message_obj.message[0:900] +
hlink('...', self.message_obj.link)
if len(self.message_obj.message) > 1024
else self.message_obj.message,
parse_mode=ParseMode.HTML,
reply_markup=await
keyboards.post_keyboard(
self.message_obj.title,
self.message_obj.link))
except WrongFileIdentifier:
try:
await self.animation()
except InvalidHTTPUrlContent:
await self.nomedia()
async def accept(m):
if m.from_user.id == m.message.entities[0].user.id:
await bot.restrict_chat_member(m.message.chat.id,
m.from_user.id,
can_send_messages=True,
can_send_media_messages=True,
can_send_other_messages=True,
can_add_web_page_previews=True)
user = f"tg://user?id={m.message.entities[0].user.id}"
user1 = hlink(f"{m.message.entities[0].user.full_name}", user)
await bot.edit_message_text(f"""🗡Приветствую, {user1}️!
Добро пожаловать!""",
chat_id=m.message.chat.id,
message_id=m.message.message_id,
disable_web_page_preview=True,
parse_mode='HTML')
await bot.edit_message_reply_markup(m.message.chat.id,
m.message.message_id)
else:
await m.answer("Ты не тот человек, для которого это сообщение!")
async def process_callback_button(callback_query: types.CallbackQuery) -> None:
await bot.answer_callback_query(callback_query.id)
pos = callback_query.data.find(' ')
media_type = callback_query.data[:pos]
media_id = callback_query.data[pos + 1:]
async with aiohttp.ClientSession() as session:
async with session.get(
find_url.with_path(f'/3/{media_type}/{media_id}').with_query({
'api_key':
api_key,
'language':
'ru'
})) as resp:
result = json.loads(await resp.text())
rating = result['vote_average'] if result[
'vote_count'] else 'неизвестен'
overview = result['overview'] if result[
'overview'] else 'отсутствует'
await bot.send_photo(
callback_query.from_user.id,
tmdb_url.with_path('/t/p/w600_and_h900_bestv2' +
result['poster_path']).human_repr(),
f"Рейтинг: {rating}\n"
f"Описание: {overview}")
link = markdown.hlink(
'прошу',
tmdb_url.with_path(f"/{media_type}"
f"/{result['id']}"
f"/watch").with_query({
'locale': 'RU'
}).human_repr())
await bot.send_message(callback_query.from_user.id,
'Если захочешь посмотреть, то ' + link,
disable_web_page_preview=True,
parse_mode='HTML')
async def create_invoice(call: types.CallbackQuery, state: FSMContext):
await call.answer(cache_time=60)
item_id = call.data.split(":")[-1]
item_id = int(item_id)
item: Item = await select_item(item_id)
amount = item.price
payment = Payment(amount=amount)
payment.create()
await call.message.answer("\n".join([
f"Оплатите не менее {amount:.2f} по номеру телефона или по адресу", "",
hlink(config.WALLET_QIWI, url=payment.invoice),
"И обязательно укажите ID платежа:",
hcode(payment.id)
]),
reply_markup=paid_keyboard)
await state.set_state("qiwi")
await state.update_data(payment=payment)
async def text_report_admins(message: types.Message):
logger.info(
"User {user} report message {message} in chat {chat} from user {from_user}",
user=message.from_user.id,
message=message.message_id,
chat=message.chat.id,
from_user=message.reply_to_message.from_user.id,
)
if not message.reply_to_message:
return await message.reply(
_(
"Please use this command is only in reply to message what do you want to report "
"and this message will be reported to chat administrators."
)
)
admins: List[types.ChatMember] = await message.chat.get_administrators()
text = _("[ALERT] User {user} is reported message in chat {chat}.").format(
user=message.from_user.get_mention(),
chat=hlink(
message.chat.title,
f"https://t.me/{message.chat.username}/{message.reply_to_message.message_id}",
)
if message.chat.username
else quote_html(repr(message.chat.title)),
)
admin_ids = [
admin.user.id for admin in admins if admin.is_chat_admin() and not admin.user.is_bot
]
if admin_ids:
for admin in await User.query.where(
User.id.in_(admin_ids) & (User.do_not_disturb == False) # NOQA
).gino.all(): # NOQA
with suppress(Unauthorized):
await bot.send_message(admin.id, text)
logger.info("Send alert message to admin {admin}", admin=admin.id)
await asyncio.sleep(0.3)
await message.reply_to_message.reply(_("This message is reported to chat administrators."))
async def text_report_admins(message: types.Message):
logger.info(
"User {user} report message {message} in chat {chat} from user {from_user}",
user=message.from_user.id,
message=message.message_id,
chat=message.chat.id,
from_user=message.reply_to_message.from_user.id,
)
if not message.reply_to_message:
return await message.reply(
"Используйте эту команду в ответ (реплай) на нужное сообщение пользователя"
)
admins: List[types.ChatMember] = await message.chat.get_administrators()
text = "[РЕПОРТ] Пользователь {user} пожаловался на другого пользователя в чате {chat}.".format(
user=message.from_user.get_mention(),
chat=hlink(
message.chat.title,
f"https://t.me/{message.chat.username}/{message.reply_to_message.message_id}",
) if message.chat.username else quote_html(repr(message.chat.title)),
)
admin_ids = [
admin.user.id for admin in admins
if admin.is_chat_admin() and not admin.user.is_bot
]
if admin_ids:
for admin in await User.query.where(User.id.in_(admin_ids)).gino.all():
with suppress(Unauthorized):
await bot.send_message(admin.id, text)
logger.info("Send alert message to admin {admin}",
admin=admin.id)
await asyncio.sleep(0.3)
reply_msg = await message.reply_to_message.reply(
"Ваша жалоба была отправлена!")
await asyncio.sleep(30)
await reply_msg.delete()
async def watch_get_six(m: types.Message, user: dict, chat: dict):
pic_url = 'https://user-images.githubusercontent.com/24507532/97610210-a0decc00-1a25-11eb-9622-7b1e3536dfc0.png'
get = await bot.send_message(
m.chat.id,
text=hide_link(pic_url) + hbold('🎉 GET /hw/ 6️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣') +
'\n\n' +
"Забавный факт - если поделить гет на 100, то получится цена RTX 3070!"
)
try:
await bot.pin_chat_message(m.chat.id,
get.message_id,
disable_notification=False)
except:
pass
await bot.send_message(
94026383,
text='GET @{} {}'.format(
m.chat.username,
hlink(str(get.message_id),
'https://t.me/{}/{}'.format(m.chat.username,
get.message_id))))
SkipHandler()
async def enter_buy(call: CallbackQuery, callback_data: dict,
state: FSMContext):
await call.answer(text="Покупка товара")
user = await select_user(call.from_user.id)
if not user.email:
await call.message.answer(
"Перед началом оплаты нужно указать вашу <b>электронную почту</b>\n"
"На нее будут приходить оплаченые мастер классы\n"
"Почта вводится один раз\n\n"
"Используйте /email для того чтобы указать почту")
return
else:
item_id = callback_data.get("item_id")
item = await get_item(item_id)
purchase = Purchase()
purchase.buyer_id = user.id
purchase.item_id_id = int(item_id)
purchase.receiver = call.from_user.full_name
payment = Payment(amount=item.price)
payment.create()
markup = await paid_keyboard()
await call.message.answer("\n".join([
f"Оплатите не менее {item.price:.2f} ₽ по ссылке ниже",
"Обязательно проверьте, что указан ID платежа:",
hcode(payment.id),
f"Убедитесь в правильности введенного вами email адресса {user.email}",
"",
hlink("Нажмите, чтобы перейти к оплате", url=payment.invoice),
]),
reply_markup=markup)
await state.update_data(payment=payment, item=item)
await state.update_data(user_id=user.user_id, purchase=purchase)
await state.set_state("qiwi")
async def process_callback_visit_lesson(callback_query: types.CallbackQuery):
buttons = buttons_constructor.init_inline(buttons=dialog.command_buttons)
await bot.answer_callback_query(callback_query.id)
await bot.send_chat_action(callback_query.from_user.id, "Typing")
user = await get_or_create_user(
telegram_id=callback_query.from_user.id,
first_name=callback_query.from_user.first_name,
)
session = await check_for_session(
bot=bot, user=user, buttons=buttons, telegram_id=callback_query.from_user.id
)
if session is None:
return
site_events = SiteEvents(login_session=session)
visited_lessons: list = site_events.go_to_lesson()
reply_text = []
for visited_lesson in visited_lessons:
reply_text.append(
md.text(
dialog.visit_lessons.format(
lesson_name=visited_lesson["subject"],
link=md.hlink("Lesson url", visited_lesson["link"]),
)
)
)
await bot.send_message(
callback_query.from_user.id,
md.text(*reply_text, sep="\n"),
reply_markup=buttons,
parse_mode=types.message.ParseMode.HTML,
)