LichessStatTgWeb/LichessWebView/app.py

from flask import Flask, jsonify, render_template
from flask_cors import CORS
import sqlite3
import sys
import os
from datetime import datetime, date

app = Flask(__name__)
CORS(app)

# Путь к базе данных бота
DB_PATH = "/app/data/lichess_bot.db"

# Add parent directory to path to import message_counters
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'LichessClientTG_bot'))
try:
    from message_counters import MessageCounters
except ImportError:
    # Fallback if import fails
    MessageCounters = None

@app.route('/')
def index():
    """Главная страница"""
    return render_template('index.html')

@app.route('/api/users')
def get_users():
    """Получить всех пользователей"""
    try:
        with sqlite3.connect(DB_PATH) as conn:
            cursor = conn.cursor()
            
            # Получаем всех пользователей
            cursor.execute('''
                SELECT 
                    tu.user_id,
                    tu.username,
                    tu.first_name,
                    tu.last_name,
                    tu.created_at,
                    COUNT(ug.id) as gamer_count,
                    SUM(CASE WHEN ug.is_active = 1 THEN 1 ELSE 0 END) as active_gamers,
                    SUM(CASE WHEN ug.period_minutes > 0 THEN 1 ELSE 0 END) as monitored_gamers
                FROM telegram_users tu
                LEFT JOIN user_gamers ug ON tu.user_id = ug.user_id
                GROUP BY tu.user_id, tu.username, tu.first_name, tu.last_name, tu.created_at
                ORDER BY COALESCE(tu.first_name, tu.username, '')
            ''')
            
            rows = cursor.fetchall()
            users = []
            
            for row in rows:
                users.append({
                    'user_id': row[0],
                    'username': row[1] or '-',
                    'first_name': row[2] or '-',
                    'last_name': row[3],
                    'created_at': row[4],
                    'gamer_count': row[5],
                    'active_gamers': row[6],
                    'monitored_gamers': row[7]
                })
            
            # Получаем общее количество игроков (уникальных)
            cursor.execute('''
                SELECT COUNT(DISTINCT g.id)
                FROM gamers g
            ''')
            total_gamers = cursor.fetchone()[0]
            
            # Get message counters statistics
            message_stats = {}
            if MessageCounters:
                try:
                    counters = MessageCounters(db_path=DB_PATH)
                    message_stats = counters.get_stats_summary()
                except Exception as e:
                    print(f"Error getting message counters: {e}")
                    message_stats = {
                        'total_all_time': 0,
                        'total_today': 0,
                        'by_command': {}
                    }
            else:
                message_stats = {
                    'total_all_time': 0,
                    'total_today': 0,
                    'by_command': {}
                }
            
            return jsonify({
                'success': True,
                'users': users,
                'total_users': len(users),
                'total_gamers': total_gamers,
                'message_stats': message_stats
            })
    
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/users/<int:user_id>/gamers')
def get_user_gamers(user_id):
    """Получить игроков конкретного пользователя"""
    try:
        with sqlite3.connect(DB_PATH) as conn:
            cursor = conn.cursor()
            
            # Получаем игроков пользователя
            cursor.execute('''
                SELECT 
                    g.id,
                    g.username,
                    ug.token,
                    ug.is_active,
                    ug.period_minutes,
                    ug.created_at
                FROM user_gamers ug
                JOIN gamers g ON ug.gamer_id = g.id
                WHERE ug.user_id = ?
                ORDER BY g.username
            ''', (user_id,))
            
            rows = cursor.fetchall()
            gamers = []
            
            for row in rows:
                gamers.append({
                    'id': row[0],
                    'username': row[1],
                    'has_token': bool(row[2]),  # Token from user_gamers, not gamers
                    'is_active': bool(row[3]),
                    'period_minutes': row[4],
                    'created_at': row[5]
                })
            
            return jsonify({
                'success': True,
                'gamers': gamers
            })
    
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)