async def add_all_psn_to_friends(message: types.Message):
logger.info(
f'Хэндлер ADD_ALL_PSN_TO_FRIEND запущен пользователем с id {message.from_user.id} '
f'({message.from_user.full_name}, {message.from_user.username})')
await types.ChatActions.typing()
db = DB()
members = db.get_all_persons() # получаем список всех пользователей из БД
members_with_psn = []
logger.info(f'Всего профилей в БД: {len(members)}')
for user in members:
if user.psn_account is not None:
logger.debug(f'{user} - PSN указан ({user.psn_account})')
members_with_psn.append(user)
logger.info(f'Всего профилей в БД c PSN: {len(members_with_psn)}'
) # выводим список пользователей из БД с psn_id
for item in members_with_psn:
logger.info(f'профилей в БД c PSN - {item}')
ps_pars = PSN_Bot(PSN_USERNAME, PSN_EMAIL,
PSN_PASSWORD) # создаем экземпляр браузера
if not ps_pars.is_logged_in_func(): # проверяем, залогинены ли мы
ps_pars.login() # если нет, то логинимся
psn_friends = ps_pars.friends_list(ps_pars.username)
logger.info(f'Друзей в PSN: {len(psn_friends)}') # выводим кол-во друзей
i = 0
for item in psn_friends:
logger.info(f': {i} друг - {item}') # выводим кол-во друзей в PSN
i += 1
members_with_psn_not_friend = members_with_psn
for user in members_with_psn:
for psn_friend in psn_friends:
if user.psn_account == psn_friend['psn']:
logger.info(f'найден друг с PSN: {user.psn_account}')
members_with_psn_not_friend.remove(user)
logger.info(
f'Пользователей в БД, указавших PSN, но не подружившихся с ботом: {len(members_with_psn_not_friend)}'
) # выводим кол-во друзей
for member_with_psn_not_friend in members_with_psn_not_friend:
logger.info(f'{member_with_psn_not_friend.psn_account}')
for user in members_with_psn_not_friend:
try:
if ps_pars.psn_status(user.psn_account) == 'Добавить Друга':
sleeptime = random.randrange(3, 10)
await asyncio.sleep(sleeptime)
ps_pars.add_to_friend(user.psn_account)
await message.answer(
str(user.psn_account + ' - направлен в друзья направлен'))
elif ps_pars.psn_status(user.psn_account) == 'Вы подписаны':
await message.answer('Скорее всего с пользователем ' +
user.psn_id + ' вы уже друзья')
elif ps_pars.psn_status(user.psn_account) == 'Подписаться':
await message.answer('запрос на добавление ' +
user.psn_account +
' уже был ранее отправлен')
else:
logging.exception("Что-то не так")
except:
logging.exception("Exception occurred")
async def edit_mentioned_person_in_bd(message: types.Message,
state: FSMContext):
logger.info(
f'Хэндлер edit_person запущен пользователем с id {message.from_user.id} '
f'({message.from_user.full_name}, {message.from_user.username})')
await types.ChatActions.typing()
await OrderEditUser.step_0.set() # Устанавливаем состояние step_0
cod_user: Person
# находим кол-во упомянутых пользователей
persons = mentioned_user_list(message)
print('Кол-во идентифицированных упомянутых пользователей: ', len(persons))
# если 0, то или cod_user - это вы, или прерываем хендлер
db = DB()
if len(persons) == 0:
update_tg_account(message.from_user)
if db.is_tg_account_exists(message.from_user.id) is False:
await message.answer(
str(message.from_user.first_name) +
", для выполнения данной команды вы должны зарегистрироваться."
+
"\nДля регистрации напишите боту в ПРИВАТНОМ ЧАТЕ команду: /add_me"
)
return
else:
tg_account = db.get_tg_account(tg_id=message.from_user.id)
cod_user = db.get_person_by_tg_account(tg_account=tg_account)
logger.info(
f'В тексте сообщения не найдено упоминаний людей, ранее зарегистрированных в базе данных.'
)
await message.reply(
'В тексте сообщения не найдено упоминаний людей, ранее зарегистрированных в базе данных.'
)
await message.answer('Вывожу информацию о тебе...') # tckb ytn
# если 1, то он и есть cod_user
elif len(persons) == 1:
cod_user = persons[0]
logger.info(
f'В тексте сообщения найдено упоминание пользователя, ранее зарегистрированного в базе данных'
)
await message.reply(
'В тексте сообщения найдено упоминание пользователя, ранее зарегистрированного в базе данных'
)
await message.answer('Вывожу информацию об этом пользователе...')
# если несколько - то первый из упомянутых - cod_user
else:
cod_user = persons[0]
logger.info(
f'В тексте найдено сообщения упоминание нескольких пользователей, ранее зарегистрированных в базе данных, начато редактирование пользователя {cod_user.tg_account}'
)
await message.reply(
f'В тексте найдено сообщения упоминание нескольких пользователей, ранее зарегистрированных в базе данных'
)
await message.answer(
f'Вывожу информацию об этом пользователе...{cod_user.tg_account}')
await OrderEditUser.step_1.set() # Устанавливаем состояние step_1
await edit_person_in_bd(db, cod_user, message, state)
def mentioned_user_list(message: types.Message):
"""Возвращает списком всех упомянутых пользователей"""
tg_account_list = []
db = DB()
members = []
# часть кода, чтобы узнать есть ли в сообщении текст, кроме текста команд
message_text = message.text
pattern = re.compile('/+\w{0,100}') # паттерн, для нахождения команд в тексте
all_commands = re.findall(pattern, message_text) # список всех команд в тексте
for item in all_commands:
message_text = message_text.replace(item, '', 1)
print('ТЕКСТ БЕЗ КОМАНД: ', message_text)
if message_text == '':
print('а текст то пустой =)')
return []
# часть кода, для mention
pattern = re.compile('@+\w{0,100}') # паттерн, для нахождения упоминаний в тексте
username_list = re.findall(pattern, message.text) # Список упоминаний по username в данном сообщении
logger.info(f'В указанном тексте {len(username_list)} упоминаний по username')
if len(username_list) > 0:
for mention in username_list:
mention = mention.replace('@', '') # Удалим из списка символ @
logger.info(f'обнаружено упоминание Username = {mention}')
tg_account = db.get_tg_account(tg_username=mention)
if tg_account is not None:
tg_account_list.append(tg_account)
# часть кода, для text_mention
text_mentions = []
for entity in message.entities:
if entity.type == 'text_mention':
text_mentions.append(entity)
logger.info(f'В указанном тексте {len(text_mentions)} упоминаний по text_mention')
if len(text_mentions) > 0:
for entity in text_mentions: # перебираем сущности, являюзиеся текстовыми упоминаниями
if entity.type == 'text_mention': # если находим упоминания
logger.info('text_mention обнаружен')
tg_account = db.get_tg_account(tg_id=entity.user.id)
if tg_account is not None:
tg_account_list.append(tg_account)
if len(tg_account_list) > 0:
for tg_account in tg_account_list:
member = db.get_person_by_tg_account(tg_account)
if member is not None:
logger.info(f'найден аккаунт, соответствующий данному username: {member}')
members.append(member)
else:
logger.info(f'аккаунт, соответствующий {tg_account} не обнаружен')
return members
async def show_stats_all(message: types.Message, is_reply=True):
"""показывает статистику всех игроков в базе данных"""
logger.info(
f'Хэндлер STATS_ALL запущен пользователем с id {message.from_user.id} '
f'({message.from_user.full_name}, {message.from_user.username})')
await types.ChatActions.typing()
db = DB()
members = db.get_all_persons()
logger.info(f'Из БД загружено {len(members)} записей')
await message.answer(text=f'Кол-во записей в БД: {len(members)}',
reply=True)
for person in members:
await types.ChatActions.typing()
name_or_nickname = 'empty'
if person.name_or_nickname is not None:
name_or_nickname = str(person.name_or_nickname)
username = '******'
if person.tg_account.username is not None:
username = str(person.tg_account.username)
activision_account = 'empty'
if person.activision_account is not None:
activision_account = str(person.activision_account)
psn_account = 'empty'
if person.psn_account is not None:
psn_account = str(person.psn_account)
kd_warzone = 'empty'
if person.kd_warzone is not None:
kd_warzone = str(float(person.kd_warzone))
kd_multiplayer = 'empty'
if person.kd_multiplayer is not None:
kd_multiplayer = str(float(person.kd_multiplayer))
kd_cold_war_multiplayer = 'empty'
if person.kd_cold_war_multiplayer is not None:
kd_cold_war_multiplayer = str(float(
person.kd_cold_war_multiplayer))
modified_kd_at = 'empty'
if person.modified_kd_at is not None:
modified_kd_at = str(person.modified_kd_at.strftime("%d.%m.%Y")) + \
'\n' + str(person.modified_kd_at.strftime("%H:%M:%S"))
text_by_strings = [
'Имя/ник: ' + name_or_nickname, 'Имя в Телеге: ' + username,
'Аккаунт ACTIVISION: ' + activision_account,
'Аккаунт PSN: ' + psn_account, 'К/Д WarZone: ' + kd_warzone,
'К/Д в мультиплеере(MW19): ' + kd_multiplayer,
'К/Д в Cold War: ' + kd_cold_war_multiplayer, '', 'Last update: ',
modified_kd_at
]
full_text = '\n'.join(
text_by_strings) # красивый способ объеденить строки с пререносами
await message.answer(text=full_text, reply=False)
async def stat_update_handler(message: types.Message):
await types.ChatActions.typing()
db = DB()
tg_account = db.get_tg_account(tg_id=message.from_user.id)
if tg_account is not None:
member = db.get_person_by_tg_account(tg_account=tg_account)
print(member)
if await stat_update(person=member, db=db):
await message.answer(message.from_user.first_name +
", статистика обновлена")
else:
await message.answer(
message.from_user.first_name +
", вам необходимо уточнить свой ACTIVISION_ID, для этого воспользуйтесь командой /add_me"
)
async def edit_person_step_3(query: types.CallbackQuery, state: FSMContext):
await types.ChatActions.typing()
db = DB()
# tg_account = db.get_tg_account(tg_id=query.from_user.id)
# cod_user = db.get_person_by_tg_account(tg_account=tg_account)
#
# # callback_data = query.data
# if data == 'отмена':
# await paused_and_canceled(query, state)
# elif data == 'name_or_nickname':
#
for text, data in text_and_data:
if data == query.data:
if query.data == 'platform_name':
inline_kb_platform = types.InlineKeyboardMarkup(row_width=2)
platforms = db.get_all_platforms()
for platform in platforms:
print(platform)
inline_platform_button = types.InlineKeyboardButton(
text=platform.name, callback_data=platform.id)
inline_kb_platform.insert(inline_platform_button)
inline_kb_platform.add(cancel_inline_button)
await bot.send_message(
chat_id=query.message.chat.id,
text=f'Какую платформу указать как основную?',
reply_markup=inline_kb_platform)
elif query.data == 'input_device_name':
inline_kb_device = types.InlineKeyboardMarkup()
devices = db.get_all_platforms()
for device in devices:
inline_device_button = types.InlineKeyboardButton(
text=device.name, callback_data=device)
inline_kb_device.add(inline_device_button)
inline_kb_device.add(cancel_inline_button)
await bot.send_message(
chat_id=query.message.chat.id,
text=f'Какое устройство ввода указать как основное?',
reply_markup=types.inline_kb_device)
else:
await bot.send_message(
chat_id=query.message.chat.id,
text=f'Введите {text}',
reply_markup=types.ReplyKeyboardRemove())
async def stats_update_all(message: types.Message):
logger.info(
f'Хэндлер stats_update_all запущен пользователем с id {message.from_user.id} '
f'({message.from_user.full_name}, {message.from_user.username})')
await types.ChatActions.typing()
db = DB()
players = db.get_all_persons()
for player in players:
await types.ChatActions.typing()
if player is not None: # проверяем, смогли ли мы загрузить свою учётку в БД
if player.modified_kd_at is None:
logger.info(f'КД ранее ни разу удачно не обновлялось')
need_to_update_kd = True
else:
logger.info(
f'Последнее удачное обновление КД произошло {player.modified_kd_at}'
)
# сколько прошло секунд с последнего обновления
timestamp_delta = datetime.now().timestamp(
) - player.modified_kd_at.timestamp()
# переводим секунды в часы, с округлением вниз
hours_delta_int = math.floor(timestamp_delta / (60 * 60))
logger.info(
f'Последнее удачное обновление КД было {hours_delta_int} часов назад'
)
hours = 10 # как часто обновлять КД
if hours_delta_int > hours:
need_to_update_kd = True
else:
need_to_update_kd = False
logger.info(
f'КД обновляется на чаще раза в {hours} часов. Еще не пришло время обновлять КД'
)
if need_to_update_kd:
logger.info(f'Обновляем КД')
await stat_update(db=db, person=player)
await message.answer(
f'статистика игрока с аккаунтом ACTIVISION {player.activision_account} обновлена'
)
else:
await message.answer(
f'Обновление статистики для игрока с аккаунтом ACTIVISION {player.activision_account} не требуется'
)
await message.answer(
message.from_user.first_name +
", обновление статистики по всем пользователям закончена!")
def update_tg_account(from_tg_user) -> bool:
"""Обновляем аккаунт телеграм в БД"""
db = DB()
try:
tg_account = db.get_tg_account(tg_id=from_tg_user.id)
tg_account.username = from_tg_user.username
tg_account.first_name = from_tg_user.first_name
tg_account.is_bot = from_tg_user.is_bot
tg_account.language_code = from_tg_user.language_code
tg_account.modified_at = datetime.now()
db.session.add(tg_account)
db.session.commit()
logger.info(f'{tg_account} - успешное обновление в БД')
return True
except Exception as ex:
logger.info(f'Обновление в БД с ОШИБКОЙ {ex}')
db.session.rollback()
return False
async def edit_me_in_bd(message: types.Message, state: FSMContext):
logger.info(
f'Хэндлер edit_me запущен пользователем с id {message.from_user.id} '
f'({message.from_user.full_name}, {message.from_user.username})')
await types.ChatActions.typing()
await OrderEditUser.step_0.set() # Устанавливаем состояние step_0
db = DB()
update_tg_account(message.from_user)
if db.is_tg_account_exists(message.from_user.id) is False:
await message.answer(
str(message.from_user.first_name) +
", для выполнения данной команды вы должны зарегистрироваться." +
"\nДля регистрации перейдите в ПРИВАТНЫЙ ЧАТ с ботом", )
await state.finish()
return
else:
tg_account = db.get_tg_account(tg_id=message.from_user.id)
person = db.get_person_by_tg_account(tg_account=tg_account)
await OrderEditUser.step_1.set() # Устанавливаем состояние step_1
await edit_person_in_bd(db, person, message, state)
async def command_me(message: types.Message, state: FSMContext):
message_id = message.message_id
await types.ChatActions.typing()
data = await state.get_data()
logger.info(f'Пользователь {message.from_user.full_name} '
f'(ID: {message.from_user.id}) указал значение {message.text}')
db = DB()
person = Person(tg_account=TG_Account(id=message.from_user.id))
if data['selected_account'] == 'psn_account':
person.psn_account = message.text
if data['selected_account'] == 'blizzard_account':
person.blizzard_account = message.text
if data['selected_account'] == 'activision_account':
person.psn_account = message.text
if data['selected_account'] == 'xbox_account':
person.psn_account = message.text
db.session.add(person)
db.session.commit()
update_tg_account(from_tg_user=message.from_user)
db.session.commit()
text = [
f'{message.from_user.full_name}, спасибо за регистрацию.',
'',
f'Что я могу для тебя сделать?',
]
inline_kb = inline_kb1_shoe_profile_or_stats
await CommandMeState.show_profile_or_stats.set()
joined_text = '\n'.join(text)
await bot.edit_message_text(chat_id=message.from_user.id,
message_id=data['main_message_id'],
text=joined_text,
reply_markup=inline_kb)
await bot.delete_message(chat_id=message.from_user.id,
message_id=message_id)
db.close()
async def add_user_to_bd_step_1(message: types.Message):
logger.info(
f'Хэндлер add_me запущен пользователем с id {message.from_user.id} '
f'({message.from_user.full_name}, {message.from_user.username})')
await types.ChatActions.typing()
db = DB()
if db.is_tg_account_exists(message.from_user.id):
await message.answer(
str(message.from_user.first_name) +
", вы уже были зарегистрированы ранее." +
"\nДля внесения изменений воспользуйтесь командой: /edit_me")
else:
tg_account = TG_Account(id=message.from_user.id,
username=message.from_user.username,
first_name=message.from_user.first_name,
is_bot=message.from_user.is_bot,
language_code=message.from_user.language_code,
modified_at=datetime.now())
person = Person(tg_account=tg_account)
try:
db.session.add(person)
db.session.commit()
await message.answer(
str(message.from_user.first_name) +
", спасибо за регистрацию." +
"\nДля внесения изменений воспользуйтесь командой: /edit_me")
except Exception as ex:
db.session.rollback()
logger.error(ex)
keyboard = types.ReplyKeyboardMarkup(resize_keyboard=True)
keyboard.add("отмена")
await message.answer(
"Для правильной работы сообщите мне ACTIVISION_ID:\n" +
"\nпример: Ivan_Ivanov#123456789",
reply_markup=keyboard)
await OrderAddUser.waiting_for_enter_activision_id.set()
async def command_me(message: types.Message, state: FSMContext):
data = await state.get_data()
main_message_id = data['main_message_id']
selected_key = data['selected_key']
logger.info(
f'Пользователь {message.from_user.full_name} (ID: {message.from_user.id})'
f' решил отредактировать {selected_key} и указал значение {message.text}'
)
async with state.proxy() as data:
data['selected_value'] = message.text
await types.ChatActions.typing()
db = DB()
tg_account = db.get_tg_account(tg_id=message.from_user.id)
person = db.get_person_by_tg_account(tg_account=tg_account)
if selected_key == 'name_or_nickname':
person.name_or_nickname = message.text
elif selected_key == 'activision_account':
person.activision_account = message.text
elif selected_key == 'blizzard_account':
person.blizzard_account = message.text
elif selected_key == 'psn_account':
person.psn_account = message.text
elif selected_key == 'xbox_account':
person.xbox_account = message.text
elif selected_key == 'about_yourself':
person.about_yourself = message.text
elif selected_key == 'platform_name':
pass
elif selected_key == 'input_device_name':
pass
else:
logger.error(f'НЕОПОЗНАННЫЙ ВЫБОР!!!! {selected_key}')
db.update_person(person) # сохраним внесённые изменения
full_text = f'<b>{selected_key}</b> удачно изменён на <b>{message.text}</b>\n\n' + \
profile_info(person) + '\n\n<b>Хотите изменить что-то ещё?</b>'
await asyncio.sleep(2)
await bot.delete_message(chat_id=message.from_user.id,
message_id=message.message_id)
await bot.edit_message_text(chat_id=message.from_user.id,
message_id=main_message_id,
text=full_text,
parse_mode=types.ParseMode.HTML,
reply_markup=inline_kb_edit_or_not)
await CommandMeState.edit_profile.set()
db.close()
async def command_me(query: types.CallbackQuery, state: FSMContext):
await types.ChatActions.typing()
data = await state.get_data()
logger.info(f'Пользователь {query.from_user.full_name} '
f'(ID: {query.from_user.id}) нажал кнопку {query.data}')
db = DB()
tg_account = db.get_tg_account(tg_id=query.from_user.id)
person = db.get_person_by_tg_account(tg_account=tg_account)
input_device = db.get_all_input_devices(id=query.data)[0]
person.input_device = input_device.id
db.update_person(person)
await bot.answer_callback_query(callback_query_id=query.id)
message_text = "Данные об устройстве ввода, которое вы используете для игры в Call of Duty, успешно обновлены!"
await bot.edit_message_text(chat_id=query.from_user.id,
message_id=data['main_message_id'],
text=message_text,
reply_markup=inline.inline_kb_go_back,
parse_mode=types.ParseMode.HTML)
db.close()
async def show_full_profile_info(message: types.Message, is_reply=True):
"""показывает данные пользователя"""
logger.info(
f'Хэндлер show_full_profile_info запущен пользователем с id {message.from_user.id} '
f'({message.from_user.full_name}, {message.from_user.username})')
await types.ChatActions.typing()
update_tg_account(message.from_user)
db = DB()
if not db.get_person_by_tg_account(db.get_tg_account(
message.from_user.id)):
await message.answer(
'Для отображения статистики необходимо сообщить мне свой ACTIVISION ID: /add_me',
reply=True)
else:
tg_acc = db.get_tg_account(message.from_user.id)
print(tg_acc)
cod_user = db.get_person_by_tg_account(tg_acc)
print(cod_user)
full_text = full_profile_info(cod_user)
await message.answer(full_text, reply=is_reply, parse_mode=text())
async def callback_show_profile(query: types.CallbackQuery, state: FSMContext):
await types.ChatActions.typing()
data = await state.get_data()
main_message_id = data['main_message_id']
print(f'{main_message_id=}')
logger.info(
f'Пользователь {query.from_user.full_name} '
f'(ID: {query.from_user.id}) нажал инлайн кнопку ПОКАЗАТЬ ПРОФИЛЬ')
await bot.answer_callback_query(callback_query_id=query.id)
db = DB()
tg_account = db.get_tg_account(tg_id=query.from_user.id)
person = db.get_person_by_tg_account(tg_account=tg_account)
full_text = profile_info(person) + '\n\n<b>Хотите изменить профиль?</b>'
await bot.edit_message_text(chat_id=query.from_user.id,
message_id=main_message_id,
text=full_text,
parse_mode=types.ParseMode.HTML,
reply_markup=inline_kb_edit_or_not)
await CommandMeState.edit_profile.set()
db.close()
def profile_info(cod_user: Person) -> str:
"""Возвращает информацию о Пользователе в виде текста"""
db = DB()
if cod_user.platform is not None:
platform = db.get_all_platforms(id=cod_user.platform)[0]
platform_name = platform.name
else:
platform_name = None
if cod_user.input_device is not None:
input_device = db.get_all_input_devices(id=cod_user.input_device)[0]
input_device_name = input_device.name
else:
input_device_name = None
if cod_user.modified_at is not None:
modified_at = str(cod_user.modified_at.strftime("%d.%m.%Y %H:%M"))
else:
modified_at = None
db.close()
text_by_strings = [
f'Информация о пользователе:',
'',
f'Порядковый номер в базе данных: {cod_user.id}',
f'Имя или ник: <b>{cod_user.name_or_nickname}</b>',
f'Аккаунт ACTIVISION: <b>{cod_user.activision_account}</b>',
f'Аккаунт PSN: <b>{cod_user.psn_account}</b>',
f'Аккаунт Blizzard: <b>{cod_user.blizzard_account}</b>',
f'Аккаунт Xbox: <b>{cod_user.xbox_account}</b>',
f'Предпочитаемая платформа: <b>{platform_name}</b>',
f'Предпочитаемое устройство ввода: <b>{input_device_name}</b>',
f'О себе: <b>{cod_user.about_yourself}</b>',
f'',
f'Last update: {modified_at}'
]
full_text = '\n'.join(text_by_strings) # красивый способ объеденить строки с пререносами
return full_text
async def command_me(message: types.Message, state: FSMContext):
logger.info(
f'Пользователь {message.from_user.full_name} (ID: {message.from_user.id}) нажал команду ME'
)
text = 'Привет, друг! Подожди буквально пару секунд, я проверю, зарегистрирован ли ты в базе данных...'
main_message = await message.answer(text=text)
async with state.proxy() as data:
data['main_message_id'] = main_message.message_id
await types.ChatActions.typing()
await asyncio.sleep(1)
db = DB()
tg_account = db.get_tg_account(tg_id=message.from_user.id)
if db.is_person_exists(tg_account): # если пользователь уже есть в БД
logger.info('Пользователь уже был зарегистрирован ранее в БД')
text = [
f'Привет, {message.from_user.full_name}, '
f'а я тебя помню!!!',
f'Что я могу для тебя сделать?',
]
inline_kb = inline_kb1_shoe_profile_or_stats
await CommandMeState.show_profile_or_stats.set()
else:
logger.info('Пользователя нет в БД')
text = [
f'Привет, {message.from_user.full_name}, как я понял, мы с тобой ещё не знакомы?!',
'', f'Для корректной работы БОТА прошу тебя зарегистрироваться '
f'и указать любой из перечисленных аккаунтов, привязанных к Call of Duty...'
]
inline_kb = inline.kb_account
await CommandMeState.account_is_selected.set()
joined_text = '\n'.join(text)
await bot.edit_message_text(chat_id=message.from_user.id,
message_id=main_message.message_id,
text=joined_text,
reply_markup=inline_kb)
db.close()
async def callback_show_profile(query: types.CallbackQuery, state: FSMContext):
logger.info(
f'Пользователь {query.from_user.full_name} '
f'(ID: {query.from_user.id}) нажал инлайн кнопку РЕДАКТИРОВАТЬ ПРОФИЛЬ'
)
await types.ChatActions.typing()
data = await state.get_data()
main_message_id = data['main_message_id']
await bot.answer_callback_query(callback_query_id=query.id)
db = DB()
tg_account = db.get_tg_account(tg_id=query.from_user.id)
person = db.get_person_by_tg_account(tg_account=tg_account)
full_text = '<b>Выберите, что вы хотите изменить?</b>'
# await asyncio.sleep(1)
await bot.edit_message_text(chat_id=query.from_user.id,
message_id=main_message_id,
text=(profile_info(person) + '\n\n' +
full_text),
parse_mode=types.ParseMode.HTML,
reply_markup=inline_kb_edit_data)
await CommandMeState.choose_what_to_edit.set()
db.close()
async def command_me(query: types.CallbackQuery, state: FSMContext):
await types.ChatActions.typing()
data = await state.get_data()
main_message_id = data['main_message_id']
logger.info(f'Пользователь {query.from_user.full_name} '
f'(ID: {query.from_user.id}) нажал кнопку {query.data}')
db = DB()
tg_account = db.get_tg_account(tg_id=query.from_user.id)
person = db.get_person_by_tg_account(tg_account=tg_account)
chose_text = ''
previous_value = 'НЕ УКАЗАН'
if query.data == 'name_or_nickname':
chose_text = 'ИМЯ или НИКНЕЙМ'
previous_value = person.name_or_nickname
elif query.data == 'activision_account':
chose_text = 'Аккаунт ACTIVISION'
previous_value = person.activision_account
elif query.data == 'psn_account':
chose_text = 'Аккаунт PlayStationNetwork'
previous_value = person.psn_account
elif query.data == 'blizzard_account':
chose_text = 'Аккаунт BLIZZARD (BATTLENET)'
previous_value = person.blizzard_account
elif query.data == 'xbox_account':
chose_text = 'Аккаунт XBOX'
previous_value = person.xbox_account
elif query.data == 'platform_name':
chose_text = 'Платформа (PC/PS/XBOX/...)'
if person.platform is not None:
previous_value = person.platform.name
elif query.data == 'input_device_name':
chose_text = 'Устройство ввода (клавомышь/геймпад)'
if person.input_device is not None:
previous_value = person.input_device.name
elif query.data == 'about_yourself':
chose_text = 'О себе'
previous_value = person.about_yourself
elif query.data == 'go_back':
logger.error(
f'ОШИБКА, кол бэк го бэк должен был поймать другой хендлер!!!!')
else:
logger.error(f'НЕОПОЗНАННЫЙ ВЫБОР!!!!{query.data}')
async with state.proxy() as data:
data['selected_key'] = query.data
text = [
profile_info(person), f'{query.from_user.full_name}, '
f'ты выбрал редактирование <b>{chose_text}</b>.',
f'Предыдущее значение - <b>{previous_value}</b>',
f'Напиши ниже новое значение...'
]
# inline_kb = inline_kb1_shoe_profile_or_stats
# await CommandMeState.show_profile_or_stats.set()
joined_text = '\n'.join(text)
await bot.edit_message_text(chat_id=query.from_user.id,
message_id=main_message_id,
text=joined_text,
parse_mode=types.ParseMode.HTML)
db.close()
await CommandMeState.edit_value_selected_before.set()
async def callback_show_statistics(query: types.CallbackQuery,
state: FSMContext):
await types.ChatActions.typing()
data = await state.get_data()
main_message_id = data['main_message_id']
logger.info(
f'Пользователь {query.from_user.full_name} '
f'(ID: {query.from_user.id}) нажал инлайн кнопку ПОКАЗАТЬ СТАТИСТИКУ')
db = DB()
await bot.answer_callback_query(callback_query_id=query.id)
tg_account = db.get_tg_account(tg_id=query.from_user.id)
update_tg_account(query.from_user)
person = db.get_person_by_tg_account(tg_account=tg_account)
update_statistics_if_needs(db, person)
await types.ChatActions.typing()
name_or_nickname = 'empty'
if person.name_or_nickname is not None:
name_or_nickname = str(person.name_or_nickname)
username = '******'
if person.tg_account.username is not None:
username = str(person.tg_account.username)
activision_account = 'empty'
if person.activision_account is not None:
activision_account = str(person.activision_account)
psn_account = 'empty'
if person.psn_account is not None:
psn_account = str(person.psn_account)
kd_warzone = 'empty'
if person.kd_warzone is not None:
kd_warzone = str(float(person.kd_warzone))
kd_multiplayer = 'empty'
if person.kd_multiplayer is not None:
kd_multiplayer = str(float(person.kd_multiplayer))
kd_cold_war_multiplayer = 'empty'
if person.kd_cold_war_multiplayer is not None:
kd_cold_war_multiplayer = str(float(person.kd_cold_war_multiplayer))
modified_kd_at = 'empty'
if person.modified_kd_at is not None:
modified_kd_at = str(person.modified_kd_at.strftime("%d.%m.%Y")) + \
'\n' + str(person.modified_kd_at.strftime("%H:%M:%S"))
text_by_strings = [
f'Имя/ник: <b>{name_or_nickname}</b>',
f'Имя в Телеге: <b>{username}</b>',
f'Аккаунт ACTIVISION: <b>{activision_account}</b>',
f'Аккаунт PSN: <b>{psn_account}</b>',
f'К/Д WarZone: <b>{kd_warzone}</b>',
f'К/Д в мультиплеере(MW19): <b>{kd_multiplayer}</b>',
f'К/Д в Cold War: <b>{kd_cold_war_multiplayer}</b>', '',
f'Last update: ', f'<b>{modified_kd_at}</b>'
]
full_text = '\n'.join(text_by_strings)
await bot.edit_message_text(chat_id=query.from_user.id,
message_id=main_message_id,
text=full_text,
parse_mode=types.ParseMode.HTML,
reply_markup=inline.inline_kb_go_back)
db.close()
await CommandMeState.show_profile_or_stats.set()
from random import shuffle
from aiogram import types
from keyboards.inline.cancel_button import go_back_button
from utils.db_api.alchemy import DB
kb_platform = types.InlineKeyboardMarkup(
row_width=1) # создаём экземпляр клавиатуры
db = DB()
platforms = db.get_all_platforms()
shuffle(platforms)
for platform in platforms:
button = types.InlineKeyboardButton(text=platform.name,
callback_data=platform.id)
kb_platform.add(button)
kb_platform.add(go_back_button) # добавляем кнопку отмена
db.close()
async def show_stat(message: types.Message):
logger.info(
f'Хэндлер STAT запущен пользователем с id {message.from_user.id} '
f'({message.from_user.full_name}, {message.from_user.username})')
"""показывает статистику игрока"""
await types.ChatActions.typing()
db = DB()
update_tg_account(message.from_user)
members = mentioned_user_list(message)
# если упоминаний нет, то добавляем в список себя
if len(members) == 0:
logger.info(
f'Не найдено ни каких упоминаний, выводим статистику по себе...')
tg_account = db.get_tg_account(tg_id=message.from_user.id)
logger.info(f'{tg_account=}')
try:
me = db.get_person_by_tg_account(tg_account)
if me is not None: # проверяем, смогли ли мы загрузить свою учётку в БД
if me.modified_kd_at is None:
logger.info(f'КД ранее ни разу удачно не обновлялось')
need_to_update_kd = True
else:
logger.info(
f'Последнее удачное обновление КД произошло {me.modified_kd_at}'
)
# сколько прошло секунд с последнего обновления
timestamp_delta = datetime.now().timestamp(
) - me.modified_kd_at.timestamp()
# переводим секунды в часы, с округлением вниз
hours_delta_int = math.floor(timestamp_delta / (60 * 60))
logger.info(
f'Последнее удачное обновление КД было {hours_delta_int} часов назад'
)
hours = 10 # как часто обновлять КД
if hours_delta_int > hours:
need_to_update_kd = True
else:
need_to_update_kd = False
logger.info(
f'КД обновляется на чаще раза в {hours} часов. Еще не пришло время обновлять КД'
)
if need_to_update_kd:
logger.info(f'Обновляем КД')
await stat_update(db=db, person=me)
members.append(me)
except Exception as ex:
print(ex)
await message.answer(
'Ошибка: пользователь не найден в базе данных.\nДля работы БОТА необходимо открыть ПРИВАТНЫЙ чат с ним и зарегистрироваться.',
reply=True)
for person in members:
await types.ChatActions.typing(2)
name_or_nickname = 'empty'
if person.name_or_nickname is not None:
name_or_nickname = str(person.name_or_nickname)
username = '******'
if person.tg_account.username is not None:
username = str(person.tg_account.username)
activision_account = 'empty'
if person.activision_account is not None:
activision_account = str(person.activision_account)
psn_account = 'empty'
if person.psn_account is not None:
psn_account = str(person.psn_account)
kd_warzone = 'empty'
if person.kd_warzone is not None:
kd_warzone = str(float(person.kd_warzone))
kd_multiplayer = 'empty'
if person.kd_multiplayer is not None:
kd_multiplayer = str(float(person.kd_multiplayer))
kd_cold_war_multiplayer = 'empty'
if person.kd_cold_war_multiplayer is not None:
kd_cold_war_multiplayer = str(float(
person.kd_cold_war_multiplayer))
modified_kd_at = 'empty'
if person.modified_kd_at is not None:
modified_kd_at = str(person.modified_kd_at.strftime("%d.%m.%Y")) + \
'\n' + str(person.modified_kd_at.strftime("%H:%M:%S"))
text_by_strings = [
'Имя/ник: ' + name_or_nickname, 'Имя в Телеге: ' + username,
'Аккаунт ACTIVISION: ' + activision_account,
'Аккаунт PSN: ' + psn_account, 'К/Д WarZone: ' + kd_warzone,
'К/Д в мультиплеере(MW19): ' + kd_multiplayer,
'К/Д в Cold War: ' + kd_cold_war_multiplayer, '', 'Last update: ',
modified_kd_at
]
full_text = '\n'.join(
text_by_strings) # красивый способ объеденить строки с пререносами
await message.answer(text=full_text, reply=True)
from random import shuffle
from aiogram import types
from keyboards.inline.cancel_button import go_back_button
from utils.db_api.alchemy import DB
kb_input_device = types.InlineKeyboardMarkup(
row_width=1) # создаём экземпляр клавиатуры
db = DB()
input_devices = db.get_all_input_devices()
shuffle(input_devices)
for input_device in input_devices:
button = types.InlineKeyboardButton(text=input_device.name,
callback_data=input_device.id)
kb_input_device.add(button)
kb_input_device.add(go_back_button) # добавляем кнопку отмена
db.close()