Upload 12 files

.gitattributes

@@ -1,2 +1,3 @@
 *.bin filter=lfs diff=lfs merge=lfs -text
 *.pth filter=lfs diff=lfs merge=lfs -text
+instance/chats.db filter=lfs diff=lfs merge=lfs -text

admin.py

@@ -0,0 +1,121 @@
+from flask import Blueprint, render_template, jsonify, request, flash, redirect, url_for
+from flask_login import login_required, current_user
+from models import User, Chat, AnalysisReport
+from extensions import db
+from datetime import datetime, timedelta
+from sqlalchemy import func
+
+admin_bp = Blueprint('admin_bp', __name__, template_folder='templates')
+
+
+@admin_bp.before_request
+@login_required
+def restrict_admin_panel():
+    if not current_user.is_admin:
+        flash('Доступ запрещен', 'danger')
+        return redirect(url_for('index'))
+
+
+@admin_bp.route('/')
+def dashboard():
+    # Статистика за последние 30 дней
+    end_date = datetime.now()
+    start_date = end_date - timedelta(days=30)
+
+    # Основная статистика
+    users_count = User.query.count()
+    new_users = User.query.filter(User.created_at >= start_date).count()
+    reports_count = AnalysisReport.query.count()
+    active_users = db.session.query(Chat.user_id).distinct().count()
+
+    # Статистика по эмоциям
+    emotion_stats = db.session.query(
+        AnalysisReport.emotion,
+        func.count(AnalysisReport.id).label('count')
+    ).group_by(AnalysisReport.emotion).all()
+
+    # Активность пользователей
+    user_activity = db.session.query(
+        User.username,
+        func.count(AnalysisReport.id).label('report_count')
+    ).join(
+        AnalysisReport, User.id == AnalysisReport.user_id
+    ).group_by(
+        User.username
+    ).order_by(
+        func.count(AnalysisReport.id).desc()
+    ).limit(10).all()
+
+    return render_template('admin/dashboard.html',
+                           users_count=users_count,
+                           new_users=new_users,
+                           reports_count=reports_count,
+                           active_users=active_users,
+                           emotion_stats=emotion_stats,
+                           user_activity=user_activity)
+
+
+@admin_bp.route('/users')
+def manage_users():
+    search_query = request.args.get('search', '')
+    page = request.args.get('page', 1, type=int)
+
+    query = User.query.order_by(User.created_at.desc())
+
+    if search_query:
+        query = query.filter(User.username.ilike(f'%{search_query}%') |
+                             User.email.ilike(f'%{search_query}%'))
+
+    users = query.paginate(page=page, per_page=20, error_out=False)
+
+    return render_template('admin/users.html',
+                           users=users,
+                           search_query=search_query)
+
+
+@admin_bp.route('/reports')
+def view_reports():
+    emotion_filter = request.args.get('emotion')
+    page = request.args.get('page', 1, type=int)
+
+    query = AnalysisReport.query.order_by(AnalysisReport.created_at.desc())
+
+    if emotion_filter:
+        query = query.filter(AnalysisReport.emotion == emotion_filter)
+
+    reports = query.paginate(page=page, per_page=50, error_out=False)
+
+    # Получаем список всех эмоций для фильтра
+    emotions = db.session.query(
+        AnalysisReport.emotion.distinct().label('emotion')
+    ).all()
+
+    return render_template('admin/reports.html',
+                           reports=reports,
+                           emotions=emotions,
+                           current_emotion=emotion_filter)
+
+
+@admin_bp.route('/toggle_admin/<int:user_id>', methods=['POST'])
+def toggle_admin(user_id):
+    user = User.query.get_or_404(user_id)
+    user.is_admin = not user.is_admin
+    db.session.commit()
+    return jsonify({'status': 'success', 'is_admin': user.is_admin})
+
+
+@admin_bp.route('/delete_user/<int:user_id>', methods=['POST'])
+def delete_user(user_id):
+    if current_user.id == user_id:
+        return jsonify({'status': 'error', 'message': 'Нельзя удалить себя'}), 400
+
+    user = User.query.get_or_404(user_id)
+
+    # Удаляем все связанные данные пользователя
+    AnalysisReport.query.filter_by(user_id=user_id).delete()
+    Chat.query.filter_by(user_id=user_id).delete()
+
+    db.session.delete(user)
+    db.session.commit()
+
+    return jsonify({'status': 'success'})

app.py

@@ -12,7 +12,10 @@ import sqlite3
 from pathlib import Path
 import whisper
 from extensions import db, login_manager
-
+import json
+from admin import admin_bp
+from flask_migrate import Migrate
+from models import User
 
 instance_path = Path(__file__).parent / 'instance'
 instance_path.mkdir(exist_ok=True, mode=0o755)
@@ -27,7 +30,7 @@ app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
 db.init_app(app)
 login_manager.init_app(app)
 login_manager.login_view = 'auth_bp.login'
-
+migrate = Migrate(app, db)
 # Инициализация моделей
 def init_models():
     try:
@@ -63,12 +66,38 @@ models = init_models()
 if not models:
     raise RuntimeError("Не удалось загрузить модели")
 
+
+@app.template_filter('datetimeformat')
+def datetimeformat(value, format='%d.%m.%Y %H:%M'):
+    if value is None:
+        return ""
+    return value.strftime(format)
+
+@app.context_processor
+def utility_processor():
+    return {
+        'emotion_map': {
+            'joy': '😊 Радость',
+            'neutral': '😐 Нейтрально',
+            'anger': '😠 Злость',
+            'sadness': '😢 Грусть',
+            'surprise': '😲 Удивление'
+        },
+        'get_emotion_color': lambda emotion: {
+            'joy': '#00b894',
+            'neutral': '#636e72',
+            'anger': '#d63031',
+            'sadness': '#0984e3',
+            'surprise': '#fdcb6e'
+        }.get(emotion, '#4a4ae8')
+    }
 # Импорт Blueprint
 from auth import auth_bp
 from profile import profile_bp
 
 app.register_blueprint(auth_bp)
 app.register_blueprint(profile_bp)
+app.register_blueprint(admin_bp, url_prefix='/admin')
 
 # Делаем переменные доступными
 emotion_map = models['emotion_map']
@@ -76,6 +105,21 @@ speech_to_text_model = models['speech_to_text_model']
 text_classifier = models['text_classifier']
 audio_classifier = models['audio_classifier']
 
+@app.cli.command('create-admin')
+def create_admin():
+    """Создание администратора"""
+    email = input("Введите email: ")
+    password = input("Введите пароль: ")
+    user = User.query.filter_by(email=email).first()
+    if user:
+        user.is_admin = True
+        user.set_password(password)
+    else:
+        user = User(email=email, username=email, is_admin=True)
+        user.set_password(password)
+        db.session.add(user)
+    db.session.commit()
+    print(f"Администратор {email} создан")
 
 def transcribe_audio(audio_path):
     """Преобразование аудио в текст с помощью Whisper"""
@@ -94,29 +138,12 @@ login_manager = LoginManager(app)
 login_manager.login_view = 'login'
 
 
-# Модель пользователя для Flask-Login
-class User(UserMixin):
-    def __init__(self, id, username, email, password_hash):
-        self.id = id
-        self.username = username
-        self.email = email
-        self.password_hash = password_hash
-
-    def check_password(self, password):
-        return check_password_hash(self.password_hash, password)
 
 
 @login_manager.user_loader
 def load_user(user_id):
-    conn = get_db_connection()
-    user = conn.execute(
-        "SELECT id, username, email, password_hash FROM users WHERE id = ?",
-        (user_id,)
-    ).fetchone()
-    conn.close()
-    if user:
-        return User(id=user['id'], username=user['username'], email=user['email'], password_hash=user['password_hash'])
-    return None
+    from models import User
+    return User.query.get(int(user_id))
 
 
 # Инициализация БД
@@ -256,6 +283,46 @@ def index():
         conn.close()
 
 
+@app.route('/profile')
+@login_required
+def profile():
+    conn = get_db_connection()
+    try:
+        # Запрашиваем все анализы пользователя
+        reports = conn.execute(
+            "SELECT * FROM analysis_reports WHERE user_id = ? ORDER BY created_at DESC",
+            (current_user.id,)
+        ).fetchall()
+
+        # Статистика: общее количество анализов
+        total_reports = len(reports)
+
+        # Статистика: самая частая эмоция
+        emotion_counts = {}
+        for r in reports:
+            emotion_counts[r['emotion']] = emotion_counts.get(r['emotion'], 0) + 1
+
+        most_common_emotion = max(emotion_counts, key=emotion_counts.get) if emotion_counts else None
+
+        return render_template(
+            "profile.html",
+            reports=reports,
+            total_reports=total_reports,
+            most_common_emotion=most_common_emotion,
+            emotion_map={
+                'joy': '😊 Радость',
+                'neutral': '😐 Нейтрально',
+                'anger': '😠 Злость',
+                'sadness': '😢 Грусть',
+                'surprise': '😲 Удивление'
+            }
+        )
+    except Exception as e:
+        flash(f"Ошибка загрузки данных: {e}", "danger")
+        return redirect(url_for('index'))
+    finally:
+        conn.close()
+
 @app.route("/analyze", methods=["POST"])
 @login_required
 def analyze_text():
@@ -356,13 +423,80 @@ def analyze_audio():
         return jsonify({'error': str(e)}), 500
 
 
+
+
+
+@app.route('/analyze_telegram_chat', methods=['POST'])
+@login_required
+def analyze_telegram_chat():
+    if 'file' not in request.files:
+        return jsonify({'error': 'No file uploaded'}), 400
+    file = request.files['file']
+    if file.filename.split('.')[-1].lower() != 'json':
+        return jsonify({'error': 'Invalid file format. Only JSON allowed'}), 400
+    try:
+        data = json.load(file)
+
+        messages = []
+        for msg in data.get('messages', []):
+            text = msg.get('text')
+            sender = msg.get('from') or msg.get('sender') or 'Неизвестный пользователь'
+            if isinstance(text, str) and len(text.strip()) > 5:
+                messages.append({
+                    'text': text,
+                    'timestamp': msg.get('date', datetime.now().isoformat()),
+                    'from': sender  # <-- сохраняем имя отправителя
+                })
+
+        if not messages:
+            return jsonify({'error': 'No valid text messages found'}), 400
+
+        results = []
+        for msg in messages[:500]:
+            prediction = text_classifier(msg['text'])[0]
+            results.append({
+                'text': msg['text'],
+                'emotion': prediction['label'],
+                'confidence': prediction['score'],
+                'timestamp': msg['timestamp'],
+                'from': msg['from']  # <-- передаем дальше
+            })
+
+        conn = get_db_connection()
+        conn.execute('''
+            CREATE TABLE IF NOT EXISTS telegram_analysis (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id INTEGER,
+                data TEXT,
+                created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY(user_id) REFERENCES users(id)
+            )
+        ''')
+        conn.execute(
+            "INSERT INTO telegram_analysis (user_id, data) VALUES (?, ?)",
+            (current_user.id, json.dumps(results))
+        )
+        conn.commit()
+
+        return jsonify({
+            'status': 'success',
+            'message_count': len(results),
+        })
+
+    except Exception as e:
+        print(f"Error during analysis: {e}")
+        return jsonify({'error': f'Server error: {str(e)}'}), 500
+    finally:
+        conn.close()
+
+
 @app.route('/get_chats')
 @login_required
 def get_chats():
     conn = get_db_connection()
     try:
         chats = conn.execute(
-            "SELECT chat_id, title FROM chats WHERE user_id = ? ORDER BY created_at DESC",
+            "SELECT chat_id, title, created_at FROM chats WHERE user_id = ? ORDER BY created_at DESC",
             (current_user.id,)
         ).fetchall()
         return jsonify([dict(chat) for chat in chats])
@@ -373,21 +507,60 @@ def get_chats():
 @app.route('/start_chat', methods=['POST'])
 @login_required
 def start_chat():
-    conn = get_db_connection()
     try:
         chat_id = str(uuid.uuid4())
+        title = f"Чат от {datetime.now().strftime('%d.%m.%Y %H:%M')}"
+
+        conn = get_db_connection()
         conn.execute(
-            "INSERT INTO chats (chat_id, user_id, title, created_at) VALUES (?, ?, ?, ?)",
-            (chat_id, current_user.id, f"Новый чат {datetime.now().strftime('%d.%m')}", datetime.now())
+            "INSERT INTO chats (chat_id, user_id, created_at, title) VALUES (?, ?, ?, ?)",
+            (chat_id, current_user.id, datetime.now(), title)
         )
         conn.commit()
-        return jsonify({"chat_id": chat_id, "title": f"Новый чат {datetime.now().strftime('%d.%m')}"})
+
+        return jsonify({
+            "success": True,
+            "chat_id": chat_id,
+            "title": title
+        })
     except Exception as e:
         return jsonify({"error": str(e)}), 500
     finally:
         conn.close()
 
 
+@app.route('/delete_chat/<chat_id>', methods=['DELETE'])
+@login_required
+def delete_chat(chat_id):
+    conn = get_db_connection()
+    try:
+        # Удаляем связанные сообщения
+        conn.execute("DELETE FROM messages WHERE chat_id = ?", (chat_id,))
+        # Удаляем сам чат
+        conn.execute("DELETE FROM chats WHERE chat_id = ? AND user_id = ?", (chat_id, current_user.id))
+        conn.commit()
+        return jsonify({"success": True})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+    finally:
+        conn.close()
+
+
+@app.route('/get_telegram_analysis')
+@login_required
+def get_telegram_analysis():
+    conn = get_db_connection()
+    try:
+        analyses = conn.execute(
+            "SELECT id, data, created_at FROM telegram_analysis WHERE user_id = ?",
+            (current_user.id,)
+        ).fetchall()
+        return jsonify([dict(analysis) for analysis in analyses])
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+    finally:
+        conn.close()
+
 @app.route('/load_chat/<chat_id>')
 @login_required
 def load_chat(chat_id):
@@ -471,5 +644,10 @@ def save_message():
     finally:
         conn.close()
 
+
+
+
 if __name__ == "__main__":
-    app.run(debug=True)
+    app.run(debug=True)
+
+

models.py

@@ -9,6 +9,7 @@ class User(UserMixin, db.Model):
     username = db.Column(db.String(50), unique=True, nullable=False)
     email = db.Column(db.String(100), unique=True, nullable=False)
     password_hash = db.Column(db.String(200), nullable=False)
+    is_admin = db.Column(db.Boolean, default=False)
     created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
     chats = db.relationship('Chat', backref='user', lazy=True)
     reports = db.relationship('AnalysisReport', backref='user', lazy=True)

requirements.txt

@@ -1,14 +1,16 @@
-flask>=2.0.0
-flask-login>=0.5.0
-flask-sqlalchemy>=2.5.1
-flask-wtf>=1.0.0
-transformers>=4.15.0
-torch>=1.9.0
-torchaudio>=0.9.0
-pydub>=0.25.1
-librosa>=0.8.0
-numpy>=1.21.0
-gunicorn
-openai-whisper
-python-dotenv>=0.19.0
-email-validator>=1.1.3
+flask==2.3.2
+werkzeug==2.3.7
+flask-login==0.6.2
+flask-sqlalchemy==2.5.1
+sqlalchemy==1.4.46
+flask-wtf==1.1.1
+transformers==4.33.3
+torch==2.1.0
+torchaudio==2.1.0
+pydub==0.25.1
+librosa==0.10.1
+numpy==1.24.3
+gunicorn==21.2.0
+openai-whisper==20231117
+python-dotenv==1.0.0
+email-validator==2.0.0.post2