927 lines
36 KiB
Python
927 lines
36 KiB
Python
import os
|
||
from dotenv import load_dotenv
|
||
import logging
|
||
import logging.config
|
||
from pprint import pprint
|
||
import pandas as pd
|
||
from transliterate import translit
|
||
import requests
|
||
from time import sleep
|
||
import datetime
|
||
import sys
|
||
from urllib.parse import urlparse
|
||
from pathlib import PureWindowsPath
|
||
import telebot
|
||
from telebot import types
|
||
from synology_drive_api.drive import SynologyDrive
|
||
from flask import Flask, jsonify
|
||
import threading
|
||
from functools import wraps
|
||
|
||
# Инициализация Flask приложения для панели мониторинга
|
||
flask_app = Flask(__name__)
|
||
flask_app.config['SECRET_KEY'] = os.getenv('FLASK_SECRET', 'default-secret-key')
|
||
|
||
# Загрузка переменных окружения
|
||
load_dotenv('AF_environment.env')
|
||
|
||
class Monitoring:
|
||
"""Класс для сбора статистики и мониторинга"""
|
||
def __init__(self):
|
||
self.jobs_history = []
|
||
self.system_stats = {
|
||
'total_jobs': 0,
|
||
'successful_jobs': 0,
|
||
'failed_jobs': 0,
|
||
'active_jobs': 0,
|
||
'users': {}
|
||
}
|
||
|
||
def add_job(self, job_data):
|
||
"""Добавление информации о новой задаче"""
|
||
self.jobs_history.append(job_data)
|
||
self.system_stats['total_jobs'] += 1
|
||
self.system_stats['active_jobs'] += 1
|
||
|
||
user_id = job_data.get('user_id')
|
||
if user_id:
|
||
if user_id not in self.system_stats['users']:
|
||
self.system_stats['users'][user_id] = {
|
||
'total_jobs': 0,
|
||
'successful_jobs': 0,
|
||
'failed_jobs': 0
|
||
}
|
||
self.system_stats['users'][user_id]['total_jobs'] += 1
|
||
|
||
def job_completed(self, job_id, success=True, user_id=None):
|
||
"""Обновление статуса завершенной задачи"""
|
||
self.system_stats['active_jobs'] -= 1
|
||
|
||
if success:
|
||
self.system_stats['successful_jobs'] += 1
|
||
else:
|
||
self.system_stats['failed_jobs'] += 1
|
||
|
||
if user_id and user_id in self.system_stats['users']:
|
||
if success:
|
||
self.system_stats['users'][user_id]['successful_jobs'] += 1
|
||
else:
|
||
self.system_stats['users'][user_id]['failed_jobs'] += 1
|
||
|
||
# Обновляем статус в истории
|
||
for job in self.jobs_history:
|
||
if job.get('job_id') == job_id:
|
||
job['status'] = 'completed' if success else 'failed'
|
||
job['completed_at'] = datetime.datetime.now()
|
||
break
|
||
|
||
def get_stats(self):
|
||
"""Получение текущей статистики"""
|
||
return self.system_stats
|
||
|
||
def get_recent_jobs(self, limit=10):
|
||
"""Получение последних задач"""
|
||
return self.jobs_history[-limit:] if self.jobs_history else []
|
||
|
||
def get_user_stats(self, user_id):
|
||
"""Получение статистики по конкретному пользователю"""
|
||
return self.system_stats['users'].get(user_id, {
|
||
'total_jobs': 0,
|
||
'successful_jobs': 0,
|
||
'failed_jobs': 0
|
||
})
|
||
|
||
class Config:
|
||
"""Класс для работы с конфигурацией приложения"""
|
||
def __init__(self):
|
||
self.nas_user = os.getenv('NAS_USER')
|
||
self.nas_pass = os.getenv('NAS_PASS')
|
||
self.nas_ip = os.getenv('NAS_IP')
|
||
self.nas_port = os.getenv('NAS_PORT')
|
||
self.nas_file = os.getenv('NAS_FILE')
|
||
self.token = os.getenv('TELEGRAM_TOKEN')
|
||
self.group_chat = os.getenv('TELEGRAM_GROUP_CHAT')
|
||
self.nexrender_url = os.getenv('NEXRENDER_URL')
|
||
self.admin_password = os.getenv('ADMIN_PASSWORD', 'admin123')
|
||
self._validate_config()
|
||
|
||
def _validate_config(self):
|
||
"""Проверка наличия обязательных переменных окружения"""
|
||
required_vars = {
|
||
'NAS_USER': self.nas_user,
|
||
'NAS_PASS': self.nas_pass,
|
||
'NAS_IP': self.nas_ip,
|
||
'TELEGRAM_TOKEN': self.token,
|
||
'NEXRENDER_URL': self.nexrender_url
|
||
}
|
||
missing = [k for k, v in required_vars.items() if not v]
|
||
if missing:
|
||
raise ValueError(f"Отсутствуют обязательные переменные окружения: {', '.join(missing)}")
|
||
|
||
class JobManager:
|
||
"""Основной класс для управления задачами рендеринга"""
|
||
def __init__(self, config, monitoring):
|
||
self.config = config
|
||
self.monitoring = monitoring
|
||
self.bot = telebot.TeleBot(config.token)
|
||
self.PLACEHOLDER = sys.platform == 'win32'
|
||
self.setup_logging()
|
||
self.setup_handlers()
|
||
|
||
if self.PLACEHOLDER:
|
||
self._init_placeholders()
|
||
|
||
def _init_placeholders(self):
|
||
"""Инициализация заглушек для тестирования"""
|
||
from random import random, choices
|
||
|
||
def send_job_dumb(data):
|
||
if random() < 0.8:
|
||
uid = ''.join(choices('abcdefghijklmnopqrstuvwxyz_', k=8))
|
||
return {'uid': uid, 'outname': data['outfile_name']}
|
||
return None
|
||
|
||
class FakeResp:
|
||
def __init__(self, state='queued', *args, **kwargs):
|
||
self.state = state
|
||
self.status_code = 200
|
||
|
||
def json(self):
|
||
return {'state': self.state}
|
||
|
||
def fake_get(*args, **kwargs):
|
||
rand = random()
|
||
if rand < 0.8:
|
||
return FakeResp()
|
||
elif rand < 0.95:
|
||
return FakeResp('finished')
|
||
else:
|
||
return FakeResp('error')
|
||
|
||
self._send_job_real = self.send_job
|
||
self.send_job = send_job_dumb
|
||
self._fake_get = fake_get
|
||
|
||
def setup_logging(self):
|
||
"""Настройка системы логирования"""
|
||
LOG_CONFIG = {
|
||
'version': 1,
|
||
'formatters': {
|
||
'detailed': {
|
||
'format': '%(asctime)s %(levelname)-8s %(name)-15s %(message)s',
|
||
'datefmt': '%Y-%m-%d %H:%M:%S'
|
||
}
|
||
},
|
||
'handlers': {
|
||
'console': {
|
||
'class': 'logging.StreamHandler',
|
||
'level': 'INFO',
|
||
'formatter': 'detailed'
|
||
},
|
||
'file': {
|
||
'class': 'logging.FileHandler',
|
||
'filename': 'af_bot.log',
|
||
'mode': 'a',
|
||
'level': 'DEBUG',
|
||
'formatter': 'detailed'
|
||
}
|
||
},
|
||
'loggers': {
|
||
'': {
|
||
'handlers': ['console', 'file'],
|
||
'level': 'DEBUG',
|
||
'propagate': True
|
||
}
|
||
}
|
||
}
|
||
logging.config.dictConfig(LOG_CONFIG)
|
||
self.logger = logging.getLogger(__name__)
|
||
|
||
def setup_handlers(self):
|
||
"""Настройка обработчиков команд Telegram"""
|
||
@self.bot.message_handler(commands=['start', 'help', 'menu'])
|
||
def send_welcome(message):
|
||
self.show_main_menu(message)
|
||
|
||
@self.bot.message_handler(func=lambda message: True)
|
||
def handle_text(message):
|
||
if message.text == '📊 Статистика':
|
||
self.show_stats(message)
|
||
elif message.text == '🔄 Создать анонс':
|
||
self.start_ibash(message)
|
||
elif message.text == '❌ Отменить задачи':
|
||
self.cancel_jobs(message)
|
||
elif message.text == '👤 Моя статистика':
|
||
self.show_user_stats(message)
|
||
else:
|
||
self.bot.reply_to(message, "Используйте меню для навигации")
|
||
|
||
@self.bot.callback_query_handler(func=lambda call: True)
|
||
def handle_callback(call):
|
||
if call.data == 'ibash_all':
|
||
self.process_ibash(call.message, all_announcements=True)
|
||
elif call.data == 'ibash_new':
|
||
self.process_ibash(call.message, all_announcements=False)
|
||
elif call.data == 'cancel':
|
||
self.bot.edit_message_text(
|
||
"Действие отменено",
|
||
call.message.chat.id,
|
||
call.message.message_id
|
||
)
|
||
self.show_main_menu(call.message)
|
||
|
||
def show_main_menu(self, message):
|
||
"""Отображение главного меню с кнопками"""
|
||
markup = types.ReplyKeyboardMarkup(
|
||
row_width=2,
|
||
resize_keyboard=True,
|
||
one_time_keyboard=False
|
||
)
|
||
|
||
buttons = [
|
||
types.KeyboardButton('🔄 Создать анонс'),
|
||
types.KeyboardButton('📊 Статистика'),
|
||
types.KeyboardButton('👤 Моя статистика'),
|
||
types.KeyboardButton('❌ Отменить задачи')
|
||
]
|
||
|
||
markup.add(*buttons)
|
||
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
"📱 *Главное меню*:\nВыберите действие:",
|
||
reply_markup=markup,
|
||
parse_mode='Markdown'
|
||
)
|
||
|
||
def show_stats(self, message):
|
||
"""Отображение статистики системы"""
|
||
stats = self.monitoring.get_stats()
|
||
recent_jobs = self.monitoring.get_recent_jobs(5)
|
||
|
||
stats_text = (
|
||
"📈 *Статистика системы*\n\n"
|
||
f"• Всего задач: {stats['total_jobs']}\n"
|
||
f"• Успешных: {stats['successful_jobs']}\n"
|
||
f"• Неудачных: {stats['failed_jobs']}\n"
|
||
f"• Активных: {stats['active_jobs']}\n\n"
|
||
"⏱ *Последние задачи*:\n"
|
||
)
|
||
|
||
for job in recent_jobs:
|
||
status_icon = '✅' if job.get('status') == 'completed' else '❌' if job.get('status') == 'failed' else '🔄'
|
||
stats_text += f"{status_icon} {job.get('name', 'N/A')} ({job.get('user', 'system')})\n"
|
||
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
stats_text,
|
||
parse_mode='Markdown'
|
||
)
|
||
|
||
def show_user_stats(self, message):
|
||
"""Отображение статистики пользователя"""
|
||
user_id = message.from_user.id
|
||
username = message.from_user.username or message.from_user.first_name
|
||
user_stats = self.monitoring.get_user_stats(user_id)
|
||
|
||
stats_text = (
|
||
f"👤 *Ваша статистика* ({username})\n\n"
|
||
f"• Всего задач: {user_stats['total_jobs']}\n"
|
||
f"• Успешных: {user_stats['successful_jobs']}\n"
|
||
f"• Неудачных: {user_stats['failed_jobs']}\n"
|
||
f"• Процент успеха: {user_stats['successful_jobs'] / user_stats['total_jobs'] * 100:.1f}%"
|
||
if user_stats['total_jobs'] > 0 else "0%"
|
||
)
|
||
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
stats_text,
|
||
parse_mode='Markdown'
|
||
)
|
||
|
||
def start_ibash(self, message):
|
||
"""Начало процесса создания анонсов с интерактивным меню"""
|
||
self.logger.info(f"Start ibash requested by {message.from_user.username}")
|
||
|
||
markup = types.InlineKeyboardMarkup()
|
||
markup.row(
|
||
types.InlineKeyboardButton("Все анонсы", callback_data="ibash_all"),
|
||
types.InlineKeyboardButton("Только новые", callback_data="ibash_new")
|
||
)
|
||
markup.row(types.InlineKeyboardButton("Отмена", callback_data="cancel"))
|
||
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
"🔧 *Создание анонсов*\n\nВыберите тип обработки:",
|
||
reply_markup=markup,
|
||
parse_mode='Markdown'
|
||
)
|
||
|
||
def process_ibash(self, message, all_announcements=False):
|
||
"""Обработка создания анонсов"""
|
||
user_id = message.from_user.id
|
||
username = message.from_user.username or message.from_user.first_name
|
||
|
||
self.bot.send_chat_action(message.chat.id, 'typing')
|
||
|
||
try:
|
||
# Загрузка данных
|
||
osheet = self.load_osheet(message)
|
||
start = self.get_sheet_data(osheet, 'Start', header=1)
|
||
|
||
if not all_announcements:
|
||
start = start[start['STATE'] == False] # Только новые анонсы
|
||
|
||
pack = self.get_sheet_data(osheet, 'SPORT', header=0, index_col='SPORT')
|
||
pack = pack[pack.index.notna()]
|
||
logos = self.get_sheet_data(osheet, 'TEAMS', header=0, index_col=[0, 1])
|
||
|
||
# Очистка старых задач
|
||
self.cleanup_old_jobs()
|
||
|
||
# Создание задач
|
||
self.bot.send_chat_action(message.chat.id, 'record_video')
|
||
watch_list = []
|
||
|
||
for i, row in start.iterrows():
|
||
dd = self.make_data_dict(row)
|
||
jobs = self.make_job_dicts(dd, pack, logos, message)
|
||
|
||
for job in jobs:
|
||
if job:
|
||
job_data = {
|
||
'job_id': job['uid'],
|
||
'name': job['outname'],
|
||
'user_id': user_id,
|
||
'user': username,
|
||
'status': 'started',
|
||
'started_at': datetime.datetime.now()
|
||
}
|
||
self.monitoring.add_job(job_data)
|
||
watch_list.append(job)
|
||
|
||
self.logger.info(f"В очереди {len(watch_list)} задач")
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
f"🚀 Запущено {len(watch_list)} задач на рендеринг",
|
||
parse_mode='Markdown'
|
||
)
|
||
|
||
# Отслеживание выполнения
|
||
self.track_jobs(message, watch_list, user_id)
|
||
|
||
except Exception as e:
|
||
self.logger.exception("Ошибка в process_ibash")
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
f"❌ Ошибка при создании анонсов: {str(e)}",
|
||
parse_mode='Markdown'
|
||
)
|
||
|
||
def track_jobs(self, message, watch_list, user_id):
|
||
"""Отслеживание выполнения задач"""
|
||
while watch_list:
|
||
self.bot.send_chat_action(message.chat.id, 'record_video')
|
||
sleep(25)
|
||
|
||
for job in watch_list[:]:
|
||
try:
|
||
if self.PLACEHOLDER:
|
||
r = self._fake_get()
|
||
else:
|
||
r = requests.get(f"{self.config.nexrender_url}/{job['uid']}")
|
||
|
||
if r.status_code == 200:
|
||
state = r.json()['state']
|
||
if state == 'finished':
|
||
watch_list.remove(job)
|
||
self.monitoring.job_completed(job['uid'], True, user_id)
|
||
|
||
self.logger.info(f"{job['outname']} готов, осталось {len(watch_list)}")
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
f"✅ *{job['outname']}* готов\nОсталось задач: {len(watch_list)}",
|
||
parse_mode='Markdown'
|
||
)
|
||
|
||
elif state == 'error':
|
||
watch_list.remove(job)
|
||
self.monitoring.job_completed(job['uid'], False, user_id)
|
||
|
||
self.logger.warning(f"{job['outname']} завершился с ошибкой")
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
f"❌ *{job['outname']}* завершился с ошибкой",
|
||
parse_mode='Markdown'
|
||
)
|
||
|
||
except Exception as e:
|
||
self.logger.error(f"Ошибка проверки статуса задачи {job['uid']}: {e}")
|
||
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
"🎉 Все задачи завершены!",
|
||
reply_markup=types.ReplyKeyboardRemove(),
|
||
parse_mode='Markdown'
|
||
)
|
||
self.show_main_menu(message)
|
||
|
||
def cleanup_old_jobs(self):
|
||
"""Очистка завершенных задач"""
|
||
try:
|
||
r = requests.get(self.config.nexrender_url)
|
||
if r.status_code == 200:
|
||
jobs = r.json()
|
||
for job in jobs:
|
||
if job['state'] in ('finished', 'error'):
|
||
requests.delete(f"{self.config.nexrender_url}/{job['uid']}")
|
||
except Exception as e:
|
||
self.logger.error(f"Ошибка очистки старых задач: {e}")
|
||
|
||
def cancel_jobs(self, message):
|
||
"""Отмена всех активных задач"""
|
||
try:
|
||
r = requests.get(self.config.nexrender_url)
|
||
if r.status_code == 200:
|
||
jobs = r.json()
|
||
cancelled = 0
|
||
|
||
for job in jobs:
|
||
if job['state'] in ('queued', 'picked'):
|
||
requests.delete(f"{self.config.nexrender_url}/{job['uid']}")
|
||
cancelled += 1
|
||
|
||
self.logger.info(f"Отменено {cancelled} задач")
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
f"⏹ Отменено {cancelled} активных задач",
|
||
parse_mode='Markdown'
|
||
)
|
||
else:
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
"⚠ Не удалось получить список задач для отмены",
|
||
parse_mode='Markdown'
|
||
)
|
||
except Exception as e:
|
||
self.logger.error(f"Ошибка отмены задач: {e}")
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
f"❌ Ошибка при отмене задач: {str(e)}",
|
||
parse_mode='Markdown'
|
||
)
|
||
|
||
def load_osheet(self, message):
|
||
"""Загрузка файла с Synology Drive"""
|
||
self.logger.debug('Получение данных')
|
||
try:
|
||
synd = SynologyDrive(
|
||
self.config.nas_user,
|
||
self.config.nas_pass,
|
||
self.config.nas_ip,
|
||
self.config.nas_port,
|
||
https=True,
|
||
dsm_version='7'
|
||
)
|
||
|
||
self.logger.debug(synd.login()) # Проверка сессии
|
||
try:
|
||
self.logger.debug('Попытка загрузки таблицы')
|
||
bio = synd.download_synology_office_file(self.config.nas_file)
|
||
self.logger.debug('Успешная загрузка')
|
||
return bio
|
||
except Exception as e:
|
||
self.logger.exception('Ошибка загрузки')
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
'<b>Не удалось скачать таблицу</b>',
|
||
parse_mode='html'
|
||
)
|
||
raise
|
||
except Exception as e:
|
||
self.logger.exception('Ошибка авторизации')
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
'<b>Не удалось авторизоваться</b>',
|
||
parse_mode='html'
|
||
)
|
||
raise
|
||
|
||
def get_sheet_data(self, osheet, sheet_name, **kwargs):
|
||
"""Получение данных из листа Excel"""
|
||
self.logger.debug(f'Чтение листа {sheet_name}')
|
||
try:
|
||
sheet = pd.read_excel(osheet, sheet_name=sheet_name, **kwargs)
|
||
self.logger.debug('Успешное чтение')
|
||
return sheet
|
||
except Exception as e:
|
||
self.logger.exception(f'Ошибка чтения листа {sheet_name}')
|
||
raise
|
||
|
||
def get_sport_logo(self, sport, pack, message):
|
||
"""Получение логотипа вида спорта"""
|
||
self.logger.info(f'Получение оформления для {sport}')
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
f'Ищем оформления для {sport}',
|
||
parse_mode='html'
|
||
)
|
||
try:
|
||
d = pack.loc[sport]['LINK']
|
||
self.logger.debug(d)
|
||
if pd.isna(d):
|
||
self.logger.warning(f'Нет LINK для вида спорта "{sport}"')
|
||
return ''
|
||
return d
|
||
except Exception as e:
|
||
self.logger.exception(f"Не удалось получить оформление для {sport}")
|
||
return ''
|
||
|
||
def get_team_logo(self, team, sport, logos, message):
|
||
"""Получение логотипа команды"""
|
||
self.logger.info(f'Получение логотипа {team}/{sport}')
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
f'Поиск логотипа {sport}-<b>{team}</b>',
|
||
parse_mode='html'
|
||
)
|
||
try:
|
||
d = logos.loc[team, sport]['LINK']
|
||
self.logger.debug(d)
|
||
return d
|
||
except KeyError:
|
||
self.logger.warning(f"Нет LINK для {team}/{sport}")
|
||
return ''
|
||
except Exception as e:
|
||
self.logger.exception(f"Ошибка при получении логотипа {sport}")
|
||
return ''
|
||
|
||
def make_data_dict(self, ds):
|
||
"""Создание словаря с данными"""
|
||
return {
|
||
'date': ds['DATA'],
|
||
'time': ds['TIME'],
|
||
'channel': ds['CHANEL'],
|
||
'sport': ds['SPORT'],
|
||
'league': ds['LEAGUE'],
|
||
'team_a': ds['TEAM A'],
|
||
'team_b': ds['TEAM B'],
|
||
'index': ds.name
|
||
}
|
||
|
||
def unc2uri(self, unc):
|
||
"""Преобразование UNC пути в URI"""
|
||
self.logger.debug('Преобразование пути')
|
||
try:
|
||
p = urlparse(unc)
|
||
if len(p.scheme) > 2 or not unc:
|
||
return unc
|
||
else:
|
||
p = PureWindowsPath(unc)
|
||
return p.as_uri()
|
||
except Exception as e:
|
||
self.logger.exception('Ошибка преобразования пути')
|
||
return unc
|
||
|
||
def send_job(self, data, message):
|
||
"""Отправка задачи на рендеринг"""
|
||
if self.PLACEHOLDER:
|
||
return self._send_job_dumb(data)
|
||
|
||
payload = {
|
||
"template": {
|
||
"src": "file:///c:/users/virtVmix-2/Downloads/PackShot_Sborka_eng.aepx",
|
||
"composition": "pack",
|
||
"outputModule": "Start_h264",
|
||
"outputExt": "mp4"
|
||
},
|
||
"actions": {
|
||
"postrender": [
|
||
{
|
||
"module": "@nexrender/action-encode",
|
||
"preset": "mp4",
|
||
"output": "encoded.mp4"
|
||
},
|
||
{
|
||
"module": "@nexrender/action-copy",
|
||
"input": "encoded.mp4",
|
||
"output": f"//10.10.35.3/edit/Auto_Anons/{data['outfile_name']}.mp4"
|
||
}
|
||
]
|
||
},
|
||
"assets": []
|
||
}
|
||
|
||
# Добавление данных в payload
|
||
self._add_data_to_payload(payload, data, message)
|
||
|
||
url = self.config.nexrender_url
|
||
try:
|
||
r = requests.post(url, json=payload)
|
||
if r.status_code == 200:
|
||
res = r.json()
|
||
uid = res['uid']
|
||
return {'uid': uid, 'outname': data['outfile_name']}
|
||
except Exception as e:
|
||
self.logger.exception('Ошибка отправки задачи')
|
||
return None
|
||
|
||
def _add_data_to_payload(self, payload, data, message):
|
||
"""Добавление данных в payload"""
|
||
# Добавление даты
|
||
self._add_date_data(payload, data, message)
|
||
|
||
# Добавление времени
|
||
self._add_time_data(payload, data, message)
|
||
|
||
# Добавление лиги
|
||
payload['assets'].append({
|
||
"type": "data",
|
||
"layerName": "LEAGUE",
|
||
"property": "Source Text",
|
||
"value": data['league']
|
||
})
|
||
|
||
# Добавление спорта
|
||
if data['sport']:
|
||
payload['assets'].append({
|
||
"type": "data",
|
||
"layerName": "SPORT",
|
||
"property": "Source Text",
|
||
"value": data['sport']
|
||
})
|
||
|
||
# Добавление команд и логотипов
|
||
self._add_team_data(payload, data, message, 'A')
|
||
self._add_team_data(payload, data, message, 'B')
|
||
|
||
# Добавление оформления
|
||
if data['pack']:
|
||
payload['assets'].append({
|
||
"src": data['pack'],
|
||
"type": "video",
|
||
"layerName": "TOP"
|
||
})
|
||
|
||
def _add_date_data(self, payload, data, message):
|
||
"""Добавление данных о дате"""
|
||
if data['data'] == 'сегодня':
|
||
self._add_specific_date_style(payload, data, message, "105", [0, 5])
|
||
elif data['data'] == 'завтра':
|
||
self._add_specific_date_style(payload, data, message, "115", [0, 25])
|
||
elif len(data['data']) < 6:
|
||
self._add_specific_date_style(payload, data, message, "120", [0, 20])
|
||
|
||
payload['assets'].append({
|
||
"type": "data",
|
||
"layerName": "DATA",
|
||
"property": "Source Text",
|
||
"value": data['data']
|
||
})
|
||
|
||
def _add_specific_date_style(self, payload, data, message, font_size, anchor_point):
|
||
"""Добавление стилей для конкретной даты"""
|
||
payload['assets'].extend([
|
||
{
|
||
"layerName": "DATA",
|
||
"property": "Source Text.fontSize",
|
||
"type": "data",
|
||
"value": font_size
|
||
},
|
||
{
|
||
"layerName": "DATA",
|
||
"property": "transform.anchorPoint",
|
||
"type": "data",
|
||
"value": anchor_point
|
||
}
|
||
])
|
||
self.logger.info(f'Для "{data["data"]}" шрифт установлен {font_size}')
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
f'Для "<i>{data["data"]}</i>" размер шрифта установлен <b>{font_size}</b>',
|
||
parse_mode='html'
|
||
)
|
||
self.logger.info(f'Сдвиг "{data["data"]}" на {anchor_point} пикселей')
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
f'<b>Сдвигаем</b> "<i>{data["data"]}</i>" на <b>{anchor_point}</b> пикселей',
|
||
parse_mode='html'
|
||
)
|
||
|
||
def _add_time_data(self, payload, data, message):
|
||
"""Добавление данных о времени"""
|
||
if len(data['time_h']) < 2:
|
||
anchor_point = [40, 0]
|
||
for layer in ["TIME_H", "TIME_M", "TIME"]:
|
||
payload['assets'].append({
|
||
"layerName": layer,
|
||
"property": "transform.anchorPoint",
|
||
"type": "data",
|
||
"value": anchor_point
|
||
})
|
||
self.logger.info(f'Сдвиг "{data["time_h"]}:{data["time_m"]}" на {anchor_point} пикселей')
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
f'<b>Сдвигаем</b> "<i>{data["time_h"]}:{data["time_m"]}</i>" на <b>{anchor_point}</b> пикседей',
|
||
parse_mode='html'
|
||
)
|
||
|
||
payload['assets'].extend([
|
||
{
|
||
"type": "data",
|
||
"layerName": "TIME_H",
|
||
"property": "Source Text",
|
||
"value": data['time_h']
|
||
},
|
||
{
|
||
"type": "data",
|
||
"layerName": "TIME_M",
|
||
"property": "Source Text",
|
||
"value": data['time_m']
|
||
}
|
||
])
|
||
|
||
def _add_team_data(self, payload, data, message, team):
|
||
"""Добавление данных о команде"""
|
||
team_key = f'team_{team.lower()}'
|
||
if data[team_key]:
|
||
payload['assets'].append({
|
||
"type": "data",
|
||
"layerName": f"TEAM_{team}",
|
||
"property": "Source Text",
|
||
"value": data[team_key]
|
||
})
|
||
|
||
logo_key = f'{team_key}_logo'
|
||
if data[logo_key]:
|
||
payload['assets'].append({
|
||
"src": data[logo_key],
|
||
"type": "image",
|
||
"layerName": f"TEAM_{team}_LOGO"
|
||
})
|
||
|
||
logo_res_key = f'{team_key}_logo_res'
|
||
if data.get(logo_res_key):
|
||
payload['assets'].append({
|
||
"property": "scale",
|
||
"type": "data",
|
||
"expression": f"if (width > height) {{max_size = width;}} else {{max_size = height;}} var real_size = {data[logo_res_key][0]}/max_size*100;[real_size,real_size]",
|
||
"layerName": f"TEAM_{team}_LOGO"
|
||
})
|
||
self.logger.info(f'{data[team_key]} логотип изменен до {data[logo_res_key][0]}')
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
f'<b>{data[team_key]}</b> масштабирован под <b>{data[logo_res_key][0]}</b> пикселей',
|
||
parse_mode='html'
|
||
)
|
||
|
||
def make_job_dicts(self, dd, pack, logos, message):
|
||
"""Создание задач рендеринга"""
|
||
self.logger.debug('Начало создания имени')
|
||
fn = ''
|
||
data = {}
|
||
empty_sport = pack.iloc[0].name
|
||
|
||
# Дата
|
||
if isinstance(dd['date'], str):
|
||
fn += f"{dd['date'][6:]}{dd['date'][3:5]}{dd['date'][0:2]}"
|
||
d = dd['date'].split('.')
|
||
data['data'] = f"{int(d[0])} {['','января','февраля','марта','апреля','мая','июня','июля','августа','сентября','октября','ноября','декабря'][int(d[1])]}"
|
||
elif isinstance(dd['date'], datetime.date):
|
||
fn += f"{dd['date'].year}{dd['date'].month:02}{dd['date'].day:02}"
|
||
data['data'] = f"{dd['date'].day} {['','января','февраля','марта','апреля','мая','июня','июля','августа','сентября','октября','ноября','декабря'][dd['date'].month]}"
|
||
|
||
# Вид спорта и оформление
|
||
if dd['sport'] != empty_sport:
|
||
fn += f"_{dd['sport']}"
|
||
data['sport'] = dd['sport']
|
||
data['pack'] = self.unc2uri(self.get_sport_logo(dd['sport'], pack, message))
|
||
else:
|
||
data['sport'] = ''
|
||
data['pack'] = ''
|
||
|
||
# Лига
|
||
if dd["league"][-1] == '.':
|
||
self.logger.debug('Точка в названии лиги!')
|
||
fn += f'_{dd["league"][:-1]}'
|
||
data['league'] = dd['league'][:-1]
|
||
else:
|
||
data['league'] = dd['league']
|
||
fn += f'_{dd["league"]}'
|
||
|
||
# Команды
|
||
self._process_team_data(dd, data, fn, 'A', logos, message)
|
||
self._process_team_data(dd, data, fn, 'B', logos, message)
|
||
|
||
# Канал
|
||
if not pd.isna(dd['channel']):
|
||
self.logger.debug('Канал установлен ' + dd['channel'])
|
||
fn += f"_{dd['channel']}"
|
||
|
||
# Финальное форматирование имени файла
|
||
fn = translit(fn, reversed=True)
|
||
fn = fn.replace(' ', '-').replace("'", '')
|
||
data['outfile_name'] = fn
|
||
|
||
# Время
|
||
if isinstance(dd['time'], str):
|
||
t = dd['time'].split(':')
|
||
data['time_h'] = t[0]
|
||
data['time_m'] = t[1]
|
||
elif isinstance(dd['time'], datetime.time):
|
||
data['time_h'] = str(dd['time'].hour)
|
||
data['time_m'] = str(dd['time'].minute)
|
||
|
||
self.logger.debug('Время ' + data['time_h'] + ':' + data['time_m'])
|
||
self.logger.debug("Конец создания имени")
|
||
|
||
# Создание задач
|
||
watch_list = []
|
||
watch_list.append(self.send_job(data, message))
|
||
|
||
if True: # TODO: Заменить на условие, если нужно
|
||
data['data'] = 'сегодня'
|
||
data['outfile_name'] = fn + '_Today'
|
||
watch_list.append(self.send_job(data, message))
|
||
data['data'] = 'завтра'
|
||
data['outfile_name'] = fn + '_Tomorrow'
|
||
watch_list.append(self.send_job(data, message))
|
||
|
||
pprint(watch_list)
|
||
return list(filter(None, watch_list))
|
||
|
||
def _process_team_data(self, dd, data, fn, team, logos, message):
|
||
"""Обработка данных команды"""
|
||
team_key = f'team_{team.lower()}'
|
||
if pd.isna(dd[f'TEAM {team}']):
|
||
self.logger.info(f'Нет команды {team}')
|
||
self.bot.send_message(
|
||
message.chat.id,
|
||
f'Нет команды {team}',
|
||
parse_mode='html'
|
||
)
|
||
data[team_key] = ''
|
||
data[f'{team_key}_logo'] = ''
|
||
data[f'{team_key}_logo_res'] = ''
|
||
else:
|
||
name = dd[f'TEAM {team}'].split('#')
|
||
fn += f"_{name[0]}"
|
||
data[f'{team_key}_logo_res'] = name[2:]
|
||
data[team_key] = name[0]
|
||
data[f'{team_key}_logo'] = self.unc2uri(
|
||
self.get_team_logo(dd[f'TEAM {team}'], dd['sport'], logos, message)
|
||
)
|
||
|
||
def run_flask():
|
||
"""Запуск Flask сервера для панели мониторинга"""
|
||
flask_app.run(host='0.0.0.0', port=5000)
|
||
|
||
@flask_app.route('/admin/stats')
|
||
def admin_stats():
|
||
"""API endpoint для получения статистики"""
|
||
stats = monitoring.get_stats()
|
||
return jsonify({
|
||
'status': 'success',
|
||
'data': stats
|
||
})
|
||
|
||
@flask_app.route('/admin/jobs')
|
||
def admin_jobs():
|
||
"""API endpoint для получения списка задач"""
|
||
jobs = monitoring.get_recent_jobs(50)
|
||
return jsonify({
|
||
'status': 'success',
|
||
'data': jobs
|
||
})
|
||
|
||
@flask_app.route('/admin/users')
|
||
def admin_users():
|
||
"""API endpoint для получения статистики по пользователям"""
|
||
stats = monitoring.get_stats()
|
||
return jsonify({
|
||
'status': 'success',
|
||
'data': stats.get('users', {})
|
||
})
|
||
|
||
if __name__ == '__main__':
|
||
try:
|
||
# Проверяем наличие файла окружения
|
||
if not os.path.exists('AF_environment.env'):
|
||
raise FileNotFoundError(
|
||
"Файл окружения AF_environment.env не найден. "
|
||
"Создайте его по образцу AF_environment.example.env"
|
||
)
|
||
|
||
# Инициализация компонентов
|
||
config = Config()
|
||
monitoring = Monitoring()
|
||
job_manager = JobManager(config, monitoring)
|
||
|
||
# Запуск Flask в отдельном потоке
|
||
flask_thread = threading.Thread(target=run_flask, daemon=True)
|
||
flask_thread.start()
|
||
|
||
# Запуск Telegram бота
|
||
job_manager.bot.infinity_polling()
|
||
|
||
# except FileNotFoundError |