async def handle(
self,
message: types.Message,
user: UserRepository,
_: dict,
album: List[types.Message],
state: FSMContext,
):
files = []
if not album:
album.append(message)
for obj in album:
if obj.photo:
files.append(obj.photo[-1].file_id)
else:
files.append(obj[obj.content_type].file_id)
#file = await message.bot.get_file(file_id)
#url = message.bot.get_file_url(file.file_path)
async with state.proxy() as data:
attachments = data.get('attachments', [])
attachments = attachments + files
data['attachments'] = attachments
await message.answer(_['attachments_accepted'])
async def storage_data_info(call: types.CallbackQuery, state: FSMContext):
await call.answer()
async with state.proxy() as data:
await call.message.answer(
text=f'{len(data) = }',
reply_markup=p_info.generate_data_info_kboard())
async def reddit(call: types.CallbackQuery, state: FSMContext):
await call.answer()
main_key = str(call.message.message_id)
async with state.proxy() as data:
post_content_len = len(data[str(
call.message.message_id)]["post_content"])
if post_content_len > 1:
await PostToReddit.which_one.set()
await call.message.edit_reply_markup(
reply_markup=p_info.generate_which_one_kboard(
post_content_len=post_content_len, ), )
else:
await PostToReddit.subreddit.set()
await call.message.edit_reply_markup(
reply_markup=p_info.generate_subreddit_kboard(
subreddit_list=config.SUBREDDIT_LIST, ), )
full_name = modify_name(name=data[main_key]["user"]["full_name"])
data["submit"] = {
"content": data[main_key]["post_content"][0],
"title":
f'{full_name} (@{data[main_key]["user"]["username"]})',
}
async def echo_photo(message: types.Message, state: FSMContext):
if str(message.chat.id) in config.admins:
photo = await bot.get_file(message.photo[-1]["file_id"])
file_url = bot.get_file_url(file_path=photo["file_path"])
title = message.caption or None
async with state.proxy() as data:
data["submit"] = {
"content": file_url,
"title": title,
}
if not title:
await message.answer_photo(
photo=message.photo[-1]["file_id"],
caption="Now you have to enter the submission title...")
await PostToReddit.enter_title.set()
else:
await message.answer_photo(
photo=message.photo[-1]["file_id"],
caption="Now choose the subreddit...",
reply_markup=p_info.generate_subreddit_kboard(
subreddit_list=config.SUBREDDIT_LIST,
),
)
await PostToReddit.subreddit.set()
else:
await message.answer("This is a photo")
async def get_phone_digit(message: types.Message, state: FSMContext):
if message.text.lower() == 'назад':
await state.reset_state()
await message.reply('Главное меню', reply_markup=await main_markup())
else:
phone = message.text
pattern_phone = \
'((8|\+7)[\- ]?)?(\()?(\d{3})?(\))?[\- ]?(\d{3})?[\- ]?(\d{2})?[\- ]?(\d{2})(\s*)(\()?(доб.)*(\s)?(\d{4})?(\))?'
new_phone_format = re.sub(pattern_phone, r"+7\4\6\7\8", phone)
await state.update_data(phone=new_phone_format)
await message.answer('Вот ваш заказ, все верно?')
product_list = []
async with state.proxy() as data:
summ = 0
for product_id, q in data['products'].items():
product = await Botbakuadmin_product.filter(
id=product_id).values('name', 'price', 'subcategory__id',
'subcategory__name', 'beer_id')
if product[0]['beer_id'] is None:
text_part = \
f'<b>{product[0]["name"].upper()}</b> {product[0]["subcategory__name"].capitalize()} -{q} шт.'
else:
text_part = f'<b>{product[0]["name"]} </b> {product[0]["subcategory__name"].capitalize()} -{q} л.'
summ += product[0]['price'] * q
product_list.append(text_part)
template = ("Сумма: {}₽\nЗаберу: {}\n{}\n{}".format(
summ, data["time"], data["name"], data["phone"]))
product_list.append(template)
msg = '\n'.join(product_list)
await message.answer(text=msg,
reply_markup=order_check_menu,
parse_mode='HTML')
await Cart.user_id.set()
async def get_phone_contact(message: types.Message, state: FSMContext):
phone = message.contact.phone_number
await state.update_data(phone=phone)
await message.answer('Вот ваш заказ, все верно?')
product_list = []
async with state.proxy() as data:
summ = 0
for product_id, q in data['products'].items():
product = await Botbakuadmin_product.filter(id=product_id).values(
'name', 'price', 'subcategory__id', 'subcategory__name',
'beer_id')
if product[0]['beer_id'] is None:
text_part = \
f'<b>{product[0]["name"].upper()}</b> {product[0]["subcategory__name"].capitalize()} -{q} шт.'
else:
text_part = f'<b>{product[0]["name"]} </b> {product[0]["subcategory__name"].capitalize()} -{q} л.'
summ += product[0]['price'] * q
product_list.append(text_part)
template = ("Сумма: {}₽\nЗаберу: {}\n{}\n{}".format(
summ, data["time"], data["name"], data["phone"]))
product_list.append(template)
msg = '\n'.join(product_list)
await message.answer(text=msg,
reply_markup=order_check_menu,
parse_mode='HTML')
await Cart.user_id.set()
async def edit_title(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data["submit"]["title"] = message.text
await message.answer(text=f'New Title: {data["submit"]["title"]}',
reply_markup=p_info.generate_subreddit_kboard(
subreddit_list=config.SUBREDDIT_LIST))
await PostToReddit.subreddit.set()
async def edit_title_callback(call: types.CallbackQuery, state: FSMContext):
async with state.proxy() as data:
text = (f'Current title: {data["submit"]["title"]}\n'
f'Enter the new one.')
try:
await call.message.edit_caption(caption=text, )
except aiogram_BadRequest:
await call.message.edit_text(text=text, )
await PostToReddit.edit_title.set()
async def enter_title(message: types.Message, state: FSMContext):
title = message.text
async with state.proxy() as data:
data["submit"]["title"] = title.strip()
await message.answer(text="Choose the subreddit now...",
reply_markup=p_info.generate_subreddit_kboard(
subreddit_list=config.SUBREDDIT_LIST, ))
await PostToReddit.subreddit.set()
async def last_twelve_posts(call: types.CallbackQuery, state: FSMContext):
await call.answer()
callback_url = call.data.replace("posts", "")
loop = asyncio.get_running_loop()
user_info = await loop.run_in_executor(None, insta.get_user_info,
callback_url)
log_event(call.message.chat.id, call.message.chat.full_name,
call.message.chat.username, level="info")
posts = user_info.get("last_twelve_posts")
if posts:
for post in posts:
caption = post_caption.format(
description=post.get("description")[:800] if post.get(
"description") else None,
likes=post.get("likes"),
comments=post.get("comments"),
)
markup = p_info.generate_post_kboard(
username=user_info["username"],
user_url=user_info["user_url"],
post_link=post["post_link"],
user_id=call.message.chat.id,
)
sent, text_msg = await send_by_content_len(
msg=call.message, post=post,
caption=caption, markup=markup,
)
if str(call.message.chat.id) in config.admins:
async with state.proxy() as data:
if isinstance(sent, types.Message):
data[sent.message_id] = post
data[sent.message_id]["user"] = {
"full_name": user_info.get("full_name"),
"username": user_info.get("username"),
}
else:
data[text_msg.message_id] = post
data[text_msg.message_id]["user"] = {
"full_name": user_info.get("full_name"),
"username": user_info.get("username"),
}
data[text_msg.message_id]["ids"] = [
message.message_id for message in sent
]
await PostToReddit.reddit.set()
else:
if user_info.get("posts_count") > 0 and len(posts) == 0:
await call.message.answer(text=private_profile_text)
log_event(call.message.chat.id, call.message.chat.full_name,
call.message.chat.username, "private profile", level="info")
elif user_info.get("posts_count") == 0:
await call.message.answer(text=no_posts_text)
async def select_notify(message: types.Message, state: FSMContext):
db_session = message.bot.get('db')
async with db_session() as session:
async with state.proxy() as data:
if message.text == "Да":
notify = True
else:
notify = False
student = Student(
telegram_id=data['telegram_id'], grp=data['group'], notify=notify)
session.add(student)
await session.commit()
await state.finish()
await menu(message)
async def send_welcome(message: types.Message, state: FSMContext):
db_session = message.bot.get('db')
# Проверяем есть ли в базе студент
async with db_session() as session:
student = await get_student(session, message.from_user.id)
if not student:
async with state.proxy() as data:
data['telegram_id'] = message.from_user.id
await RegisterState.group_select.set()
# Спрашиваем группу
with open(Settings.cmd_welcome, 'r', encoding='utf-8') as file:
await message.reply(file.read(), parse_mode='HTML', disable_web_page_preview=True)
else:
await message.answer("<b> Привет, рад тебя видеть снова </b>", parse_mode='HTML', disable_web_page_preview=True)
async def handler(message: Message,
state: FSMContext,
that_name=name): # name=name important!!
logger.info({
'from': (message.from_user.id, message.from_user.first_name,
message.from_user.username),
'text':
message.text
})
async with state.proxy() as data:
loc = await d.loc_man.get_from_db(message.from_user.id, d.db)
handler_class = cls(loc, data, d)
handler_method = getattr(handler_class, that_name)
return await handler_method(message)
async def handler(query: CallbackQuery,
state: FSMContext,
that_name=name): # name=name important!!
logger.info({
'from': (query.from_user.id, query.from_user.first_name,
query.from_user.username),
'data':
query.data
})
async with state.proxy() as data:
loc = await d.loc_man.get_from_db(query.from_user.id, d.db)
handler_class = cls(loc, data, d)
handler_method = getattr(handler_class, that_name)
return await handler_method(query)
async def reply_to_conversation(
query: types.CallbackQuery,
callback_data: typing.Dict[str, str],
user: UserRepository,
_: LangHolder,
state: FSMContext,
):
async with state.proxy() as data:
data['reply_to_conversation'] = callback_data['id']
await FeedbackForm.waiting_for_reply.set()
await query.message.edit_text(_['feedback_reply'])
await query.answer()
async def check_order(message: types.Message, state: FSMContext):
if message.text.lower() == 'назад':
await state.reset_state()
await message.reply('Главное меню', reply_markup=await main_markup())
if message.text.lower() == 'заказ верен':
await state.update_data(user_id=message.from_user.id)
product_list = []
async with state.proxy() as data:
summ = 0
for id, q in data['products'].items():
product = await Botbakuadmin_product.filter(id=id).values(
'name', 'price', 'subcategory__id', 'subcategory__name',
'beer_id')
if product[0]['beer_id'] is None:
text_part = f'<b>{product[0]["name"].upper()}</b> {product[0]["subcategory__name"].capitalize()} -{q} шт.'
else:
text_part = f'<b>{product[0]["name"]} </b> {product[0]["subcategory__name"].capitalize()} -{q} л.'
summ += product[0]['price'] * q
product_list.append(text_part)
template = ("Сумма: {}₽\nЗаберу: {}\n{}\n{}".format(
summ, data["time"], data["name"], data["phone"]))
product_list.append(template)
msg = '\n'.join(product_list)
user = await Botbakuadmin_tguser.get_or_none(
user_id=message.from_user.id)
if user is None:
await Botbakuadmin_tguser.create(user_id=message.from_user.id,
name=data["name"],
phone=data["phone"])
else:
await user.save()
admin_order_check_menu = types.InlineKeyboardMarkup()
btn_admin_order_check = types.InlineKeyboardButton(
text='ЗАКАЗ СОБРАН',
callback_data=order_user_id.new(user='******',
id=data['user_id'],
name=data['name']))
admin_order_check_menu.add(btn_admin_order_check)
await bot.send_message(data['bar'],
msg,
reply_markup=admin_order_check_menu,
parse_mode='HTML')
await bot.send_message(ORDER_CHAT_ADMIN,
'РОКЕТС \n' + msg,
parse_mode='HTML') # админ чат
await message.answer(
'Ваш заказ принят в обработку, наш сотрудник свяжется с вами в ближайшее время',
reply_markup=await main_markup())
await state.finish()
async def which_to_post(call: types.CallbackQuery, state: FSMContext):
await call.answer()
which_one = int(call.data.split(",")[1])
main_key = str(call.message.message_id)
async with state.proxy() as data:
full_name = modify_name(name=data[main_key]["user"]["full_name"])
data["submit"] = {
"content": data[main_key]["post_content"][which_one - 1],
"title": f'{full_name} (@{data[main_key]["user"]["username"]})',
}
await call.message.edit_reply_markup(
reply_markup=p_info.generate_subreddit_kboard(
subreddit_list=config.SUBREDDIT_LIST, ), )
await PostToReddit.subreddit.set()
async def select_group(message: types.Message, state: FSMContext):
db_session = message.bot.get('db')
sql = select(Group).where(Group.name == message.text)
async with db_session() as session:
request = await session.execute(sql)
group = request.scalar()
if group:
async with state.proxy() as data:
data['group'] = message.text
markup = types.ReplyKeyboardMarkup(
resize_keyboard=True, selective=True)
markup.add("Да", "Нет")
with open(Settings.cmd_group, 'r', encoding='utf-8') as file:
await message.answer(file.read(), parse_mode='HTML', disable_web_page_preview=True, reply_markup=markup)
await RegisterState.next()
else:
await message.reply("Что-то пошло не так, проверь, чтобы группа была формата ГИБО-05-19. Если не получается, значит база данных не доступна либо ваша группа не загружена.", parse_mode='HTML', disable_web_page_preview=True)
async def post(message: types.Message, state: FSMContext):
url = modify_url(url=message.text)
try:
loop = asyncio.get_running_loop()
post = await loop.run_in_executor(None, insta.get_single_post, url)
logging.info(f'{message.chat.id} | {message.chat.full_name} | '
f'{message.chat.username} | {message.text}')
except NotFoundError:
await message.answer(text=not_found_error_text)
return True
markup = p_info.generate_post_kboard(
username=post["owner_username"], user_url=post["owner_link"],
post_link=post["post_link"], user_id=message.chat.id,
)
caption = post_caption.format(
description=post.get("description")[:800] if post.get(
"description") else None,
likes=post.get("likes"), comments=post.get("comments"),
)
sent, text_msg = await send_by_content_len(
msg=message, post=post,
caption=caption, markup=markup,
)
await message.delete()
if str(message.chat.id) in config.admins:
async with state.proxy() as data:
user = await loop.run_in_executor(None, insta.get_user_info, post["owner_link"])
if isinstance(sent, types.Message):
data[sent.message_id] = post
data[sent.message_id]["user"] = {
"full_name": user.get("full_name"),
"username": user.get("username"),
}
else:
data[text_msg.message_id] = post
data[text_msg.message_id]["user"] = {
"full_name": user.get("full_name"),
"username": user.get("username"),
}
data[text_msg.message_id]["ids"] = [
message.message_id for message in sent
]
await PostToReddit.reddit.set()
async def delete_message(call: types.CallbackQuery, state: FSMContext):
await call.answer()
await call.message.delete()
async with state.proxy() as data:
message_data = data.get(str(call.message.message_id))
if message_data and message_data.get("ids"):
for msg in message_data["ids"]:
await bot.delete_message(
chat_id=call.message.chat.id,
message_id=str(msg),
)
if message_data:
del data[str(call.message.message_id)]
else:
data.pop(key="user")
log_event(str(call.message.chat.id),
call.message.chat.full_name,
call.message.chat.username,
level="info")
async def subreddit(call: types.CallbackQuery, state: FSMContext):
async with state.proxy() as data:
url = await imgur.upload_to_imgur(data["submit"]["content"])
reddit_submission = await reddit_utils.submit_post(
subreddit_name=call.data,
title=data["submit"]["title"],
url=url,
)
if reddit_submission:
await call.answer(text="Done!")
submission = await reddit_utils.get_submission_info(
submission_code=reddit_submission, )
await call.message.edit_reply_markup(
reply_markup=p_info.generate_posted_kboard(
permalink=
rf'{config.REDDIT_BASE_URL}{submission.permalink}', ), )
logging.info(
f'{call.message.chat.id} | {call.message.chat.username} | '
f'{url} | {data["submit"]["title"]} | '
f'{config.REDDIT_BASE_URL}{submission.permalink}')
del data["submit"]
await PostToReddit.reddit.set()
async def create(
self,
state: Optional[FSMContext] = None,
dbhelper: Optional[DBHelper] = None,
login: Optional[str] = None,
password: Optional[str] = None,
) -> None:
"""Async replacement for __init__"""
if state is None:
if dbhelper is None:
raise StupidError(
"UserSession.create: state == None and dbhelper == None")
state = FSMContext(storage=dbhelper,
user=self.user_id,
chat=self.user_id)
elif dbhelper is not None:
raise StupidError(
f"UserSession.create: state == {state} and dbhelper == {dbhelper}"
)
self.state = state
data: Dict = await self.state.get_data()
if password is None:
pwd_hidden: str = str(None)
else:
pwd_hidden = "_" + "*" * len(password) + "_"
if PASSWORD in data:
data_hidden = {}
for key in data:
if key == PASSWORD:
value = "_" + "*" * len(data[PASSWORD]) + "_"
else:
value = data[key]
data_hidden[key] = value
else:
data_hidden = data
logging.info(
"UserSesion create. user_id: %d login: %s, password: %s, data: %s",
self.user_id,
login,
pwd_hidden,
data_hidden,
)
if data is None and login is None and password is None:
raise StupidError("Usage error -- No info to create a UserSession")
if data is None:
if login is not None and password is not None:
self.login = login
self.password = password
self.glpi_id = self.check_cred()
self.state.set_data(
data={
LOGIN: self.login,
PASSWORD: self.password,
GLPI_ID: self.glpi_id,
LOGGED_IN: True,
})
return
if login is not None:
self.state.set_data(data={LOGIN: login})
return
if password is not None:
raise StupidError(
f"Usage error -- login is None, password = {pwd_hidden}")
flag_data_changed: bool = False
if login is not None:
data[LOGIN] = login
flag_data_changed = True
if password is not None:
data[PASSWORD] = password
flag_data_changed = True
if LOGIN in data:
self.login = data[LOGIN]
if PASSWORD in data:
self.password = data[PASSWORD]
if GLPI_ID in data:
self.glpi_id = data[GLPI_ID]
if ((login is not None or password is not None)
and self.login is not None and self.password is not None):
try:
data[GLPI_ID] = self.check_cred()
except glpi_api.GLPIError:
data[LOGGED_IN] = False
try:
del data[GLPI_ID]
except KeyError:
pass
if flag_data_changed:
await state.set_data(data=data)
raise
else:
data[LOGGED_IN] = True
flag_data_changed = True
# if LOGGED_IN in data:
# logging.info("data = %s", data)
self.is_logged_in = data.get(LOGGED_IN, False)
self.glpi_id = data.get(GLPI_ID, None)
# if GLPI_ID in data:
# self.glpi_id = data[GLPI_ID]
if flag_data_changed:
await state.set_data(data=data)
