def __init__(self, config_path, config_private_path):
with open(config_path, encoding = 'utf-8') as json_file:
config = json.load(json_file)
with open(config_private_path, encoding = 'utf-8') as json_file:
config_private = json.load(json_file)
self.config_path = config_path
self.week_index = config.get("week_index")
self.folder = config.get("folder")
self.filename = config.get("filename")
self.lesson_end_time = config.get("lesson_end_time")
self.greetings = config.get("greetings")
self.day_of_week = config.get("day_of_week")
self.lessons_schedule = config.get("lessons_schedule")
self.bot_token = config_private.get("bot_token")
self.db_url = config_private.get("db_url")
self.timetable = dict()
self.bot = aiogram.Bot(self.bot_token)
self.dp = aiogram.Dispatcher(self.bot)
self.xls = XlsHandler("../{}/{}".format(
self.folder,
self.filename
),
self.day_of_week
)
self.db = dbHandler(self.db_url)
async def CheckingQueue():
"""
"""
telebot = aiogram.Bot(token=Settings.TOKEN)
while True:
Queue = Settings.Queue.copy()
# If Queue isn't empty
if Queue:
# If status of document is 'Очередь'
if Queue[0][4] == 'Очередь':
# Change status to 'В работе'
Template.ChangeStatus()
# Get content in file
with open(Queue[0][3], 'r') as File:
Content = File.read()
await Template.UploadFile(Queue, Content, telebot)
time.sleep(1)
FilePath = ''.join([
str(pathlib.Path(__file__).parents[2]),
'\\FileSystem\\', Queue[0][0],
f'\\PDF\\{Queue[0][2][:-4]}.pdf'
])
await Template.DownloadFile(Queue, FilePath, telebot)
time.sleep(1)
# Delete line in queue
Template.DeleteLineInQueue()
time.sleep(1)
# Lowwering of queue
Template.LowweringOfQueue()
# Read document
with open(FilePath, 'rb') as File:
# Send document to user
await telebot.send_document(Queue[0][0], document=File)
time.sleep(2)
def __init__(self, config_path: str, environ: Dict[str, str]):
self.config = config.load_config(config_path, environ)
self.db = db.Db(self.config['db_path_inside_container'])
self.authorizer = authorizer.Authorizer(self.db, self.config)
self.http_client = http_client.HttpClient(self.config)
self.aio_loop = asyncio.get_event_loop()
self.bot = aiogram.Bot(token=self.config['telegram_api_token'],
loop=self.aio_loop)
print(self.config['telegram_api_token'])
async def send_notifications():
env = read_env()
bot = aiogram.Bot(token=env.str('TOKEN'), parse_mode='HTML')
while True:
async with YooMoneyExchange() as ex:
rates = await ex.get_rates()
await bot.send_message(
env.str('ADMIN_CHAT'),
'\n'.join(f'<pre>{str(el)}</pre>' for el in rates))
await asyncio.sleep(10 * 60)
def __init__(self, token: str, chat_service: services.ChatService):
self.bot = aiogram.Bot(token)
self.dp = aiogram.Dispatcher(self.bot, storage=memory.MemoryStorage())
self.chat_service = chat_service
self.dp.register_message_handler(self.welcome, commands=['start'])
self.dp.register_message_handler(self.start_set_min_price,
commands=['set_min_price'])
self.dp.register_message_handler(self.set_min_price,
state=PriceState.wait_for_min_price)
self.dp.register_message_handler(self.start_set_max_price,
commands=['set_max_price'])
self.dp.register_message_handler(self.set_max_price,
state=PriceState.wait_for_max_price)
def main():
set_logging()
bot = aiogram.Bot(BOT_TOKEN)
dispatcher = aiogram.Dispatcher(bot)
aggregator = Aggregator(rapidapi_key=RAPIDAPI_KEY)
asyncio.run(aggregator.load_sources())
dispatcher.loop.create_task(aggregator.update_periodically())
communicator = Communicator(aggregator)
register_handlers(communicator, dispatcher)
run(dispatcher)
def start_main_bot(library, token):
parameter = 'w'
directory = os.listdir('.')
text = 'Начало записи лога ' + log_time() + '\n' + \
'Номер главного _thread: ' + str(_thread.get_ident()) + '\n' + '-' * 50
if log_file_name in directory:
parameter = 'a'
text = '\n' + '-' * 50 + '\n' + text
file = open(log_file_name, parameter)
file.write(text)
file.close()
if library == 'async':
return aiogram.Bot(token)
else:
return telebot.TeleBot(token)
def __init__(self, config_path: str, environ: Dict[str, str]):
self.config = config.load_config(config_path, environ)
self.authorizer = authorizer.Authorizer(self.config)
self.share = share.Share(self.config['share_dir'])
self.db = db.Db(self.config['db_path'])
self.google_sheets_client = google_sheets_client.GoogleSheetsClient(
self.config, )
self.settings = settings.Settings(self.db)
self.aio_loop = asyncio.get_event_loop()
self.bot = aiogram.Bot(
token=self.config['telegram_api_token'],
loop=self.aio_loop,
)
self.bot_wrapper = bot_wrapper.BotWrapper(self.bot, self.share)
self.dp = _create_dispatcher(self.bot)
def __init__(self, logger, zalgo_text, token: str):
super().__init__(logger, zalgo_text, token)
self.client = aiogram.Bot(token)
self.dp = aiogram.Dispatcher(self.client)
@self.dp.message_handler(commands=['start'])
async def start(message: aiogram.types.Message):
self.logger.log_to_console_and_file("Telegram: /start")
await message.answer(
"Hello there! Type /help to know how to use me.\n"
"F E E L F R E E T O A B U S E T H I S W O R L D.(c)@@%!&")
@self.dp.message_handler(commands=['help'])
async def helper(message: aiogram.types.Message):
self.logger.log_to_console_and_file("Telegram: /help")
await message.answer(self.help_message)
@self.dp.message_handler(commands=['zalgo'])
async def zalgofy(message: aiogram.types.Message):
self.logger.log_to_console_and_file("Telegram: /zalgo")
source = message.get_args()
if source:
await message.answer(self.zalgo_text.zalgofy(source))
else:
await message.answer(
"Write text to be zalgofied after the /zalgo")
@self.dp.message_handler(lambda message: message.chat.type == 'private'
)
async def zalgofy_pm(message: aiogram.types.Message):
self.logger.log_to_console_and_file("Telegram: PM's")
await message.answer(self.zalgo_text.zalgofy(message.text))
@self.dp.inline_handler(lambda query: len(query.query) > 0)
async def zalgofy_inline(query: aiogram.types.InlineQuery):
self.logger.log_to_console_and_file("Telegram: Inline")
zalgofied_text = self.zalgo_text.zalgofy(query.query)
answer = aiogram.types.InlineQueryResultArticle(
id='1',
title=zalgofied_text,
input_message_content=aiogram.types.InputTextMessageContent(
zalgofied_text))
await query.answer([answer], cache_time=0)
def init():
evloop = asyncio.new_event_loop()
asyncio.set_event_loop(evloop)
logger.info("Don't forget to check proxy settings!")
bot_extra_settings = {}
if settings.TELEGRAM_PROXY:
bot_extra_settings['proxy'] = settings.TELEGRAM_PROXY
bot = aiogram.Bot(settings.MASTERMIND_BOT_CONFIG["token"], **bot_extra_settings,)
dsp = Dispatcher(bot)
register_handlers(dsp)
# check connection
me = evloop.run_until_complete(dsp.bot.me)
logger.info(me)
init_rpc(evloop, bot)
executor.start_polling(dsp)
def main():
global Bot
args = parse_args()
logging.basicConfig(
filename=args.logfile,
format='%(asctime)s %(levelname)-8s %(message)s',
level=logging.INFO,
datefmt='%Y-%m-%d %H:%M:%S',
)
cfg = config.load_config(args.config, os.environ)
aio_loop = asyncio.get_event_loop()
Bot = aiogram.Bot(token=cfg['bot_token'], loop=aio_loop)
dispatcher = aiogram.Dispatcher(Bot)
dispatcher.register_message_handler(handle_start, commands=['start'])
aio_loop.create_task(watch_file_changes(cfg['watched_file']))
aiogram.executor.start_polling(dispatcher, skip_updates=True)
Config.Load()
import logging
# import requests
# import asyncio
import aiogram
import Dialogues
import DialogueManager
import Templates
import ChatManager
import GoogleForm
import traceback
logging.basicConfig(level=logging.INFO)
bot = aiogram.Bot(token=Config.data['TELEGRAM']['TOKEN'])
dp = aiogram.Dispatcher(bot)
async def CheckUserForbidden(user,
message: aiogram.types.Message,
silence=False):
if message.chat.type == "group":
if "forbidden" in user and user["forbidden"]:
if "forbidden-text" in user:
if not silence:
await message.reply(
f'Извините, я не могу выполнить вашу команду в этом чате.\nПричина:\n\n{user["forbidden-text"]}'
)
return True
return False
# Возвращает медиагруппу по группе ссылок
async def create_media_group(links: list[str], caption=None):
# Создаем медиагруппу
group = aiogram.types.MediaGroup()
# Добавляем туда каждое изображение по ссылке, получая в i номер картинки
for i, link in enumerate(links):
# Если есть описание и картинка первая, то добавляем описание ей
if caption and i == 0:
group.attach_photo(await get_image(link), caption)
# Иначе добавляем просто картинку
else:
group.attach_photo(await get_image(link))
# Возвращаем группу
return group
links = [
'https://avatars.mds.yandex.net/get-zen_gallery/2369070/pub_606d6a6ebccd1a5a1ae60688_606d6acde2daae2990d36bc2/scale_720',
'https://avatars.mds.yandex.net/get-zen_gallery/1989171/pub_606d6a6ebccd1a5a1ae60688_606d6acd01bd4224ca917f63/scale_720',
'https://avatars.mds.yandex.net/get-zen_gallery/3129491/pub_606d6a6ebccd1a5a1ae60688_606d6acd743fae54808adb36/scale_720'
]
if __name__ == '__main__':
loop = asyncio.get_event_loop()
bot = aiogram.Bot(token=garrip91_TOKEN, loop=loop)
dp = aiogram.dispatcher.Dispatcher(bot=bot)
media = loop.run_until_complete(create_media_group(links, caption="123"))
loop.run_until_complete(bot.send_media_group(CHANNEL_ID, media))
key = 'is_admin'
def __init__(self, is_admin):
self.is_admin = is_admin
async def check(self, message):
member = await bot.get_chat_member(chat_id=message.chat.id,
user_id=message.from_user.id)
return member.is_chat_admin()
KICKING = False
REPORTING = True
USERS_TO_REPORT = [410584052]
TOKEN = "753583216:AAGCRN7IcAoD0licGbqw4dvhPTjwaJNu_Vc"
bot = aiogram.Bot(token=TOKEN)
dp = aiogram.Dispatcher(bot)
dp.filters_factory.bind(MyFilter)
button_click = CallbackData("Click", "action")
def get_keyboad():
return InlineKeyboardMarkup().row(
InlineKeyboardButton("Click",
callback_data=button_click.new(action="done")))
async def check_for_old_messages(time_diff):
messages_db = SQLmessages()
import sys
import pathlib
sys.path.insert(0, str(pathlib.Path(__file__).parent))
from helpers import *
from models import *
from config import *
from consts import *
import aiogram
import asyncio
bot = aiogram.Bot(BOT_HASH)
async def send():
TEST = 0
msg = 'всем ку ескул опять забанил айпишник моего сервера, так что пока я не улажу этот вопрос с их поддержкой или не перееду на другой сервер, бот лежит🤷♂️'
if not TEST:
users = get_all_users()
for user_id in users:
try:
await bot.send_message(user_id, msg, parse_mode="HTML")
except:
pass
else:
await bot.send_message(410821501, msg, parse_mode="HTML")
asyncio.run(send())
import io
import requests
import aiogram
import asyncio
from config import garrip91_TOKEN, CHANNEL_ID
from aiogram import Bot, Dispatcher, executor, filters, types
logging.basicConfig(
format=
u'%(filename)s [LINE:%(lineno)d] #%(levelname)-8s [%(asctime)s] %(message)s',
level=20)
bot = aiogram.Bot(token=garrip91_TOKEN)
dp = aiogram.dispatcher.Dispatcher(bot=bot)
# @dp.message_handler()
# async def answer_link(message: aiogram.types.Message):
# try:
# # Получение данных из интернета (байты)
# image_bytes = requests.get(message.text).content
# # Преобразование байтов в поток
# image_stream = io.BytesIO(image_bytes)
# # Преобразование потока в изображение для телеграма
# telegram_image = aiogram.types.InputFile(image_stream)
# # Отправка картинки пользователю
# await message.answer_photo(telegram_image)
# except Exception as e:
import aiogram from aiogram.contrib.fsm_storage.memory import MemoryStorage from src.core.settings import Settings bot = aiogram.Bot(Settings.TOKEN) bot.parse_mode = "HTML" dp = aiogram.dispatcher.Dispatcher(bot, storage=MemoryStorage())
import aiogram
import asyncio
import tgdbassbot.config
import tgdbassbot.messages
import json
from tgdbassbot.downloader import SongsDownloader
import tgdbassbot.keyboards
bot = aiogram.Bot(token=tgdbassbot.config.API_TOKEN,
parse_mode=aiogram.types.ParseMode.HTML)
loop = asyncio.get_event_loop()
dp = aiogram.Dispatcher(bot, loop=loop)
users = {}
@dp.message_handler(commands=['start'])
async def start_message(message: aiogram.types.Message):
if str(message.from_user.id) in users.keys():
start_message_lang = tgdbassbot.messages.start_messages[users[str(
message.from_user.id)]['language']]
await bot.send_message(message.chat.id, start_message_lang)
elif str(message.from_user.id) not in users.keys():
keyb = tgdbassbot.keyboards.Keyboards().select_lang()
await bot.send_message(
message.chat.id,
"Выбери язык\nChoose a language\nElige un idioma",
reply_markup=keyb)
users[str(message.from_user.id)] = {
"language": "",
import os
import time
from datetime import datetime as dt
from functools import wraps
import aiogram
from aiogram import types
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram.dispatcher.filters.state import StatesGroup, State
from aiogram.utils import exceptions
from creds import TELEGRAM_TOKEN, BOT_PROXY
# bot = telebot.TeleBot(TELEGRAM_TOKEN)
log = logging.getLogger('ohaioposter')
bot = aiogram.Bot(TELEGRAM_TOKEN, proxy=BOT_PROXY)
storage = MemoryStorage()
dp = aiogram.Dispatcher(bot, storage=storage)
bot.start_time = dt.fromtimestamp(time.perf_counter())
bot.users = {}
bot.paginators = {}
bot.error_msg = None
class NewNameSetup(StatesGroup):
new_name = State()
class LimitSetup(StatesGroup):
user = State()
import dotenv
import aiogram
import tinydb
from aiogram import types
from aiogram.utils import executor
from loguru import logger
from tinydb import Query
from tinydb.operations import set as set_
import parse
env = dotenv.dotenv_values()
db = tinydb.TinyDB("botdb.json")
bot = aiogram.Bot(env["BOT_TOKEN"], proxy=env["PROXY"])
dp = aiogram.Dispatcher(bot)
HELP_TEXT = """Мои комманды:
`/add <имя>` - добавляет ученика в список
`/list` - показывает список учеников
`/edit "<старое_имя>" "<новое_имя>"` - изменяет имя ученика
`/delete <имя>` - удаляет ученика из списка
`/choose` - выдает случайный список учеников
"""
@dp.message_handler(commands=["help", "start"])
async def help_(message: types.Message):
await message.reply(HELP_TEXT, parse_mode="markdown")
import aiogram
import pathlib
import urllib
import os
import typing
import asyncio
import time
from aiogram.contrib.fsm_storage import memory
from .Settings import Settings
from .BotChecks import Checks
from .Builder import Builder
bot = aiogram.Bot(token=Settings.TOKEN)
dispatcher = aiogram.Dispatcher(bot, storage=memory.MemoryStorage())
class Template:
def CreateKeyboardByInsert(
Data: list, Option: str) -> aiogram.types.InlineKeyboardMarkup:
"""
Creat InlineKeyboardMarkup.
:param list Data: [[callback_data, text], ...],
:param str Option: choosen type of keyboard
:return [InlineKeyboardMarkup, ReplyKeyboardMarkup]:
"""
# Check type of data and parametr
if isinstance(Data, list) and Option == 'Inline':
# Create object InlineKeyboardMarkup
import aiogram
import time
from bs4 import BeautifulSoup
import requests
import asyncio
from aiogram.types import ReplyKeyboardRemove, \
ReplyKeyboardMarkup, KeyboardButton, \
InlineKeyboardMarkup, InlineKeyboardButton
dayly_list = []
bot = aiogram.Bot(token='934119066:AAHSxlgxljwjZYT88lL2d7JOby_MfIc27ec')
dp = aiogram.Dispatcher(bot)
html_response = requests.get('https://yandex.ru/pogoda/staraya-russa')
soup = BeautifulSoup(html_response.text, 'html.parser')
day_parsing = soup.find('div', class_="b-page__container").find(
'div', class_="content__row content__row_with-right-margin").find(
'ul', class_="swiper-wrapper")
async def one_time_forecast():
while True:
html_response = requests.get('https://yandex.ru/pogoda/staraya-russa')
soup = BeautifulSoup(html_response.text, 'html.parser')
search_parsing = soup.find(
'div', class_="temp fact__temp fact__temp_size_s").find(
'span', class_='temp__value')
await bot.send_message(
chat_id=543176947,
text='Температура в данный момент: ' +
import aiogram as ai
import logging
import random
TOKEN = '1133381423:AAEytfr8xb5xoB9iewgDWPAwKZlMgkArW_w'
logging.basicConfig(level=logging.INFO)
bot = ai.Bot(token=TOKEN)
dp = ai.Dispatcher(bot)
menu = ai.types.ReplyKeyboardMarkup(
keyboard=[[ai.types.KeyboardButton(text="Да")],
[ai.types.KeyboardButton(text="Нет")]],
resize_keyboard=True)
@dp.message_handler(commands=['start'])
async def send_mes(message: ai.types.message):
text = "Привет, тебе " + str(random.randint(1, 100)) + "?"
await message.answer(text, reply_markup=menu)
@dp.message_handler(ai.dispatcher.filters.Text(equals=["Да", "Нет"]))
async def ans(message: ai.types.message):
if (message.text == "Да"):
await message.answer("Хорошо!",
reply_markup=ai.types.ReplyKeyboardRemove())
else:
await message.answer("Ну и пошёл вон!",
reply_markup=ai.types.ReplyKeyboardRemove())
if __name__ == '__main__':
import aiogram
import asyncio
import settings
from converters import convert_audio_format, text_to_speech
from helpers import (
clean_files,
is_valid_clean_text,
is_valid_conversion_result,
get_clean_text_with_fname,
get_validated_msg_text,
queue_task,
)
from middlewares import AccessMiddleware
bot = aiogram.Bot(token=settings.API_TOKEN)
dp = aiogram.Dispatcher(bot)
dp.middleware.setup(AccessMiddleware(settings.ACCESS_ID)) # your TG ID
logger = logging.getLogger('article_bot')
file_handler = logging.FileHandler('logs.log')
formatter = logging.Formatter('%(asctime)s %(message)s', '%Y-%m-%d %H:%M:%S')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
queue = asyncio.PriorityQueue()
@dp.message_handler(commands=['start', 'help'])
async def send_welcome(message: aiogram.types.message.Message) -> None:
'''Welcome msg from bot on first use.'''
def __init__(self, token, repository):
self.bot = aiogram.Bot(token=token)
self.repository = repository
import aiogram
import asyncio
import tgdbassbot.config
import tgdbassbot.messages
import json
from tgdbassbot.downloader import SongsDownloader
import tgdbassbot.keyboards
bot = aiogram.Bot(token="1615610481:AAHPlLTfaFHYBo2h9Ot4IoxDG-W8avU6wnQ",
parse_mode=aiogram.types.ParseMode.HTML)
loop = asyncio.get_event_loop()
dp = aiogram.Dispatcher(bot, loop=loop)
users = {}
@dp.message_handler(commands=['start'])
async def start_message(message: aiogram.types.Message):
if message.from_user.id in users.keys():
start_message_lang = tgdbassbot.messages.start_messages[users[
message.from_user.id]['language']]
await bot.send_message(message.chat.id, start_message_lang)
elif message.from_user.id not in users.keys():
keyb = tgdbassbot.keyboards.Keyboards().select_lang()
await bot.send_message(
message.chat.id,
"Выбери язык\nChoose a language\nElige un idioma",
reply_markup=keyb)
users[message.from_user.id] = {
"language": "",
from aiogram.dispatcher import FSMContext
from aiogram.utils.executor import start_webhook
from aiogram.types import ContentType
BOT_TOKEN = os.getenv("BOT_TOKEN")
STIKER_SETS = os.getenv("STIKER_SETS").split(', ')
WORDS = os.getenv("WORDS").split(', ')
HOST = "0.0.0.0"
PORT = os.getenv("PORT")
HEROKU_APP_NAME = os.getenv("HEROKU_APP_NAME")
WEBHOOK_URL = f"https://{HEROKU_APP_NAME}.herokuapp.com/{BOT_TOKEN}"
STIKERS = list()
bot = aiogram.Bot(token=BOT_TOKEN)
state_storage = MemoryStorage()
telegram_api_dispatcher = aiogram.Dispatcher(bot=bot, storage=state_storage)
def get_with_probability(probability=10):
return random.randint(0, 100) <= probability
def translate(text: str, target="uk"):
text = text.replace(' ', '|')
new_text = ts.translate_html(
text,
translator=ts.google,
to_language=target
def build_bot(app):
# pylint: disable=unused-variable
bot = aiogram.Bot(token=BOT_TOKEN)
dp = aiogram.Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
async def get_page(user_id, page=1):
keyboard = aiogram.types.InlineKeyboardMarkup()
async with get_database_connection(user_id) as db:
async with db.execute(
f'SELECT question FROM questions ORDER BY id LIMIT 6 OFFSET {(page - 1) * 6}'
) as cursor:
async for row in cursor:
keyboard.row(
aiogram.types.InlineKeyboardButton(
text=row[0], callback_data=row[0][:32]))
keyboard.row(*[
aiogram.types.InlineKeyboardButton(text=wrap_if(
f'{opage * 6 - 5}–{opage * 6}', page == opage),
callback_data=f'page:{opage}')
for opage in range(1, 4)
])
return keyboard
@dp.inline_handler()
async def search(inline_query: aiogram.types.InlineQuery):
if not inline_query.query:
return AnswerInlineQuery(inline_query.id, [])
user_id = inline_query.from_user.id
if not database_exists(user_id):
return AnswerInlineQuery(
inline_query.id, [],
is_personal=True,
cache_time=3,
switch_pm_text='Авторизуйтесь с персональной ссылкой')
results = []
try:
async with get_database_connection(user_id) as db:
if "'" in inline_query.query:
print("support: hacking attempt",
user_id,
inline_query.query.encode(),
flush=True)
async with db.execute(
'SELECT * FROM questions WHERE question LIKE \'%' +
inline_query.query + '%\' LIMIT 50') as cursor:
async for row in cursor:
if len(results) == 50:
break
results.append(
aiogram.types.InlineQueryResultArticle(
id=f'{user_id}-{gen_id(row)}',
title=row[1],
input_message_content=aiogram.types.
InputTextMessageContent(
f'\u2753 *{row[1]}*\n\n\U0001F4AC {row[2]}',
parse_mode='Markdown'),
reply_markup=aiogram.types.
InlineKeyboardMarkup(inline_keyboard=[[
aiogram.types.InlineKeyboardButton(
text='\U0001F44D Спасибо!',
callback_data='like')
]]),
description=truncate(row[2])))
except aiosqlite.OperationalError:
pass
return AnswerInlineQuery(inline_query.id,
results,
is_personal=True,
cache_time=20)
@dp.callback_query_handler()
async def navigate(callback_query: aiogram.types.CallbackQuery):
user_id = callback_query.from_user.id
if callback_query.data == 'like':
return AnswerCallbackQuery(callback_query.id,
text='Ваше мнение очень важно для нас!',
show_alert=True)
if callback_query.data.startswith('page:'):
try:
page = int(callback_query.data[5:])
except ValueError:
return AnswerCallbackQuery(callback_query.id,
text='Нет такой страницы',
show_alert=True)
questions = await get_page(user_id, page)
try:
await bot.edit_message_text(
'Выберите интересующий вас вопрос:',
user_id,
callback_query.message.message_id,
reply_markup=questions)
except aiogram.utils.exceptions.MessageNotModified:
pass
else:
async with get_database_connection(user_id) as db:
async with db.execute(
'SELECT * FROM questions WHERE question LIKE \'' +
callback_query.data + '%\' LIMIT 1') as cursor:
async for row in cursor:
await bot.edit_message_text(
f'\u2753 *{row[1]}*\n\n\U0001F4AC {row[2]}',
user_id,
callback_query.message.message_id,
parse_mode='Markdown',
reply_markup=aiogram.types.InlineKeyboardMarkup(
inline_keyboard=[[
aiogram.types.InlineKeyboardButton(
text='\U0001F44D Спасибо!',
callback_data='like')
]]))
return AnswerCallbackQuery(callback_query.id)
@dp.message_handler()
async def echo(message: aiogram.types.Message):
user_id = message.from_user.id
if message.get_command() == '/start' and message.get_args() != '':
try:
token = message.get_args()
except ValueError:
return SendMessage(
user_id,
'Пожалуйста, используйте вашу персональную ссылку для входа.'
)
if not verify_token(token):
return SendMessage(
user_id,
'Ваша персональная ссылка устарела. Обратитесь в центр Клиентской Поддержки.'
)
await init_database(user_id, token)
text = 'Добро пожаловать в Департамент клиентской поддержки! Выберите интересующий вас вопрос:'
else:
text = 'К сожалению, все операторы отсутствуют. Ваш вопрос очень важен для нас, поэтому ответ на него наверняка найдётся ниже:'
if not database_exists(user_id):
return SendMessage(
user_id,
'Пожалуйста, используйте вашу персональную ссылку для входа.')
questions = await get_page(user_id)
return SendMessage(user_id, text, reply_markup=questions)
async def startup(_):
await bot.set_webhook(f'{HOST}{WEBHOOK_PATH}')
async def shutdown(_):
await bot.delete_webhook()
aiogram.utils.executor.set_webhook(dp,
WEBHOOK_PATH,
on_startup=startup,
on_shutdown=shutdown,
skip_updates=True,
web_app=app)
from functools import singledispatchmethod
import aiogram
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from core.config import config
__all__ = ["telegram_api_dispatcher", "state_storage"]
from core.inbox.messages import DocumentMessage, TextMessage, PhotoMessage, EditTextMessage
_API_TOKEN = config["API_TOKEN"]
_bot = aiogram.Bot(token=_API_TOKEN)
state_storage = MemoryStorage()
class CustomDispatcher(aiogram.Dispatcher):
@singledispatchmethod
async def send(self, message):
...
@send.register
async def _send_document(self, message: DocumentMessage):
return await self.bot.send_document(**message.get_params_to_sent())
@send.register
async def _send_text(self, message: TextMessage):
return await self.bot.send_message(**message.get_params_to_sent())
@send.register
def readJSON(path='config.json'):
with open(path, 'rb') as f:
return json.load(f)
return None
def dumpJSON(cfg, path='config.json'):
with open(path, 'wb') as f:
f.truncate()
return json.dump(cfg, f)
return None
config = readJSON()
TGBot = aiogram.Bot(token="")
TwApp = CamTweet.CamTweet()
async def poll(pollList: list):
while (true):
asyncio.wait()
async def _poll(search: str, ):
if True:
await TGBot.send_message()
