Upload 76 files

Dockerfile

@@ -1,22 +1,66 @@
-# Utiliser une image basée sur Debian 12 "Bookworm", où wkhtmltopdf est disponible
+# Dockerfile pour Apex Ores avec Scheduler DB-Based
+# Ce Dockerfile lance à la fois l'application Flask ET le scheduler en arrière-plan
+
 FROM python:3.11-bookworm
 
-# Mettre à jour et installer wkhtmltopdf et ses dépendances
+# Mettre à jour et installer les dépendances système
 RUN apt-get update && apt-get install -y \
     wkhtmltopdf \
     xvfb \
+    supervisor \
     && rm -rf /var/lib/apt/lists/*
 
+# Créer l'utilisateur
 RUN useradd -m -u 1000 user
-USER user
-ENV PATH="/home/user/.local/bin:$PATH"
 
+# Créer les répertoires pour supervisor et les logs
+RUN mkdir -p /var/log/supervisor /var/log/apex \
+    && chown -R user:user /var/log/supervisor /var/log/apex
+
+# Définir le répertoire de travail
 WORKDIR /app
 
+# Copier et installer les dépendances Python
 COPY --chown=user ./requirements.txt requirements.txt
 RUN pip install --no-cache-dir --upgrade -r requirements.txt
 
+# Copier tout le code
 COPY --chown=user . /app
 
-# Commande de démarrage Flask
-CMD ["flask", "run", "--host=0.0.0.0", "--port=7860"]
+# Créer la configuration supervisord
+RUN echo '[supervisord]\n\
+nodaemon=true\n\
+user=root\n\
+logfile=/var/log/supervisor/supervisord.log\n\
+pidfile=/var/run/supervisord.pid\n\
+\n\
+[program:flask]\n\
+command=flask run --host=0.0.0.0 --port=7860\n\
+directory=/app\n\
+user=user\n\
+autostart=true\n\
+autorestart=true\n\
+stdout_logfile=/var/log/apex/flask.log\n\
+stderr_logfile=/var/log/apex/flask.log\n\
+environment=PYTHONPATH=/app\n\
+\n\
+[program:scheduler]\n\
+command=python3 -m app.task_runner --daemon\n\
+directory=/app\n\
+user=user\n\
+autostart=true\n\
+autorestart=true\n\
+stdout_logfile=/var/log/apex/scheduler.log\n\
+stderr_logfile=/var/log/apex/scheduler.log\n\
+environment=PYTHONPATH=/app' > /etc/supervisor/conf.d/apex.conf
+
+# Variables d'environnement
+ENV PYTHONPATH=/app
+ENV FLASK_APP=run.py
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# Exposer le port Flask
+EXPOSE 7860
+
+# Commande de démarrage : lance supervisord qui gère les deux processus
+CMD ["/usr/bin/supervisord", "-c", "/etc/supervisor/conf.d/apex.conf"]

apex-scheduler.service

@@ -0,0 +1,17 @@
+[Unit]
+Description=Apex Ores DB Task Scheduler
+After=network.target
+
+[Service]
+Type=simple
+User=gojo
+WorkingDirectory=/home/gojo/Bureau/jhjv
+Environment=PYTHONPATH=/home/gojo/Bureau/jhjv
+ExecStart=/usr/bin/python3 -m app.task_runner --daemon
+Restart=always
+RestartSec=10
+StandardOutput=append:/var/log/apex-scheduler.log
+StandardError=append:/var/log/apex-scheduler.log
+
+[Install]
+WantedBy=multi-user.target

app/__init__.py

@@ -20,28 +20,28 @@ def create_app(config_name="default"):
     login_manager.login_view = "auth.login"
     login_manager.login_message = "Veuillez vous connecter pour accéder à cette page."
 
-    from app.routes import auth, main, admin_routes, payments
+    from app.routes import auth, main, admin_routes, payments, admin_tasks
 
     app.register_blueprint(auth.bp)
     app.register_blueprint(main.bp)
     app.register_blueprint(admin_routes.bp)
     app.register_blueprint(payments.bp)
+    app.register_blueprint(admin_tasks.bp)
 
     # Global context processor for app settings
     @app.context_processor
     def inject_app_settings():
-        """Inject app name and logo into all templates"""
         from app.models import AppSettings
+
         try:
             return {
-                'app_name': AppSettings.get_app_name(),
-                'app_logo': AppSettings.get_app_logo(),
+                "app_name": AppSettings.get_app_name(),
+                "app_logo": AppSettings.get_app_logo(),
             }
         except Exception:
-            # Return defaults if database is not yet initialized
             return {
-                'app_name': 'Apex Ores',
-                'app_logo': None,
+                "app_name": "Apex Ores",
+                "app_logo": None,
             }
 
     return app

app/models/__init__.py

@@ -471,3 +471,138 @@ class Notification(db.Model):
 
     is_read = db.Column(db.Boolean, default=False)
     created_at = db.Column(db.DateTime, default=lambda: datetime.now(timezone.utc))
+
+
+class ScheduledTask(db.Model):
+    """Model for database-based scheduled tasks - replaces cron jobs"""
+
+    __tablename__ = "scheduled_tasks"
+
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(100), unique=True, nullable=False)
+    description = db.Column(db.String(255))
+
+    # Configuration
+    schedule_type = db.Column(db.String(20), default="daily")  # daily, hourly, interval
+    schedule_time = db.Column(db.Time, nullable=True)  # Heure exacte (ex: 00:05:00)
+    interval_minutes = db.Column(db.Integer, nullable=True)  # Ou intervalle
+
+    # État
+    is_active = db.Column(db.Boolean, default=True)
+    last_run_at = db.Column(db.DateTime, nullable=True)
+    next_run_at = db.Column(db.DateTime, nullable=True)
+    last_status = db.Column(
+        db.String(20), default="pending"
+    )  # pending, running, success, failed
+    last_error = db.Column(db.Text, nullable=True)
+    run_count = db.Column(db.Integer, default=0)
+    fail_count = db.Column(db.Integer, default=0)
+
+    # Métadonnées
+    created_at = db.Column(db.DateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at = db.Column(
+        db.DateTime,
+        default=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(timezone.utc),
+    )
+
+    def __repr__(self):
+        return f"<ScheduledTask {self.name}>"
+
+    def should_run(self):
+        """Vérifie si la tâche doit s'exécuter maintenant"""
+        from datetime import timezone
+
+        if not self.is_active:
+            return False
+
+        if not self.next_run_at:
+            self.calculate_next_run()
+            return True
+
+        now = datetime.now(timezone.utc)
+        next_run = self.next_run_at
+
+        if next_run.tzinfo is None:
+            next_run = next_run.replace(tzinfo=timezone.utc)
+
+        return now >= next_run
+
+    def calculate_next_run(self):
+        """Calcule la prochaine exécution"""
+        from datetime import date, time, timedelta
+
+        now = datetime.now(timezone.utc)
+
+        if self.schedule_type == "daily" and self.schedule_time:
+            # Prochaine exécution à l'heure définie
+            next_run = datetime.combine(date.today(), self.schedule_time)
+            next_run = next_run.replace(tzinfo=timezone.utc)
+            if next_run <= now:
+                next_run += timedelta(days=1)
+            self.next_run_at = next_run
+
+        elif self.schedule_type == "hourly":
+            # Toutes les heures
+            self.next_run_at = now.replace(
+                minute=0, second=0, microsecond=0
+            ) + timedelta(hours=1)
+
+        elif self.schedule_type == "interval" and self.interval_minutes:
+            # Intervalle personnalisé
+            if self.last_run_at:
+                self.next_run_at = self.last_run_at + timedelta(
+                    minutes=self.interval_minutes
+                )
+            else:
+                self.next_run_at = now
+
+    def mark_running(self):
+        """Marque la tâche comme en cours"""
+        self.last_status = "running"
+        db.session.commit()
+
+    def mark_success(self):
+        """Marque la tâche comme réussie"""
+        self.last_run_at = datetime.now(timezone.utc)
+        self.run_count += 1
+        self.last_status = "success"
+        self.last_error = None
+        self.calculate_next_run()
+        db.session.commit()
+
+    def mark_failed(self, error_message):
+        """Marque la tâche comme échouée"""
+        self.last_run_at = datetime.now(timezone.utc)
+        self.fail_count += 1
+        self.last_status = "failed"
+        self.last_error = str(error_message)[:500]  # Limiter la taille
+        self.calculate_next_run()
+        db.session.commit()
+
+
+class TaskExecutionLog(db.Model):
+    """Log d'exécution des tâches planifiées"""
+
+    __tablename__ = "task_execution_logs"
+
+    id = db.Column(db.Integer, primary_key=True)
+    task_id = db.Column(db.Integer, db.ForeignKey("scheduled_tasks.id"), nullable=False)
+    task_name = db.Column(db.String(100), nullable=False)
+
+    started_at = db.Column(db.DateTime, default=lambda: datetime.now(timezone.utc))
+    completed_at = db.Column(db.DateTime, nullable=True)
+    status = db.Column(db.String(20), default="running")  # running, success, failed
+    error_message = db.Column(db.Text, nullable=True)
+    output_log = db.Column(db.Text, nullable=True)
+
+    # Pour debug
+    server_hostname = db.Column(db.String(100), nullable=True)
+    process_id = db.Column(db.Integer, nullable=True)
+
+    task = db.relationship(
+        "ScheduledTask", backref=db.backref("execution_logs", lazy="dynamic")
+    )
+
+    def __repr__(self):
+        return f"<TaskExecutionLog {self.task_name} {self.status}>"

app/routes/admin_tasks.py

@@ -0,0 +1,123 @@
+from functools import wraps
+
+from flask import (
+    Blueprint,
+    flash,
+    jsonify,
+    redirect,
+    render_template,
+    request,
+    url_for,
+)
+from flask_login import current_user, login_required
+
+from app import db
+from app.models import ScheduledTask, TaskExecutionLog
+
+bp = Blueprint("admin_tasks", __name__, url_prefix="/admin/tasks")
+
+
+def admin_required(f):
+    """Vérifie que l'utilisateur est administrateur"""
+
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if not current_user.is_authenticated or not getattr(
+            current_user, "is_admin", False
+        ):
+            flash("Accès réservé aux administrateurs.", "error")
+            return redirect(url_for("main.index"))
+        return f(*args, **kwargs)
+
+    return decorated_function
+
+
+@bp.route("/")
+@login_required
+@admin_required
+def list_tasks():
+    """Liste toutes les tâches planifiées"""
+    tasks = ScheduledTask.query.order_by(ScheduledTask.name).all()
+
+    stats = {
+        "total": len(tasks),
+        "active": sum(1 for t in tasks if t.is_active),
+        "failed": sum(1 for t in tasks if t.last_status == "failed"),
+        "pending": sum(1 for t in tasks if t.should_run()),
+    }
+
+    return render_template("admin/tasks.html", tasks=tasks, stats=stats)
+
+
+@bp.route("/logs")
+@login_required
+@admin_required
+def view_logs():
+    """Voir l'historique des exécutions"""
+    page = request.args.get("page", 1, type=int)
+    per_page = 50
+
+    logs = TaskExecutionLog.query.order_by(TaskExecutionLog.started_at.desc()).paginate(
+        page=page, per_page=per_page, error_out=False
+    )
+
+    return render_template("admin/task_logs.html", logs=logs)
+
+
+@bp.route("/run/<int:task_id>", methods=["POST"])
+@login_required
+@admin_required
+def run_task_now(task_id):
+    """Exécute une tâche manuellement"""
+    task = ScheduledTask.query.get_or_404(task_id)
+
+    try:
+        from app.task_runner import TaskRunner
+
+        runner = TaskRunner()
+        runner.execute_task(task)
+        flash(f"Tâche '{task.name}' exécutée avec succès!", "success")
+    except Exception as e:
+        flash(f"Erreur lors de l'exécution: {str(e)}", "error")
+
+    return redirect(url_for("admin_tasks.list_tasks"))
+
+
+@bp.route("/toggle/<int:task_id>", methods=["POST"])
+@login_required
+@admin_required
+def toggle_task(task_id):
+    """Active ou désactive une tâche"""
+    task = ScheduledTask.query.get_or_404(task_id)
+    task.is_active = not task.is_active
+    db.session.commit()
+
+    status = "activée" if task.is_active else "désactivée"
+    flash(f"Tâche '{task.name}' {status}.", "success")
+
+    return redirect(url_for("admin_tasks.list_tasks"))
+
+
+@bp.route("/api/status")
+@login_required
+@admin_required
+def api_status():
+    """API JSON pour le statut des tâches (utilisé par le dashboard)"""
+    tasks = ScheduledTask.query.all()
+
+    return jsonify(
+        {
+            "tasks": [
+                {
+                    "id": t.id,
+                    "name": t.name,
+                    "status": t.last_status,
+                    "is_active": t.is_active,
+                    "last_run": t.last_run_at.isoformat() if t.last_run_at else None,
+                    "next_run": t.next_run_at.isoformat() if t.next_run_at else None,
+                    "should_run": t.should_run(),
+                }
+                for t in tasks
+            ]
+        }
+    )

app/task_runner.py

@@ -0,0 +1,287 @@
+"""
+Database-based Task Scheduler for Apex Ores
+
+Remplace les cron jobs traditionnels par un système robuste basé sur la DB:
+- Rattrapage automatique des tâches manquées après redémarrage
+- Historique complet des exécutions
+- Interface admin pour monitoring et contrôle
+- Tolérance aux pannes serveur
+
+Usage:
+    # Mode daemon (boucle infinie)
+    python -m app.task_runner --daemon
+
+    # Mode one-shot (pour cron ou test)
+    python -m app.task_runner
+
+    # Via Flask CLI
+    flask run-scheduler
+"""
+
+import sys
+import os
+import socket
+import traceback
+from datetime import datetime, timedelta, timezone, date, time
+from io import StringIO
+from contextlib import redirect_stdout
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from app import create_app, db
+from app.models import ScheduledTask, TaskExecutionLog
+
+
+class TaskRunner:
+    def __init__(self):
+        self.app = create_app()
+        self.hostname = socket.gethostname()
+        self.pid = os.getpid()
+
+    def run_pending_tasks(self):
+        """Exécute toutes les tâches qui doivent tourner"""
+        with self.app.app_context():
+            now = datetime.now(timezone.utc)
+
+            pending_tasks = ScheduledTask.query.filter(
+                ScheduledTask.is_active == True,
+                db.or_(
+                    ScheduledTask.next_run_at == None, ScheduledTask.next_run_at <= now
+                ),
+            ).all()
+
+            print(f"[{now}] {len(pending_tasks)} tâche(s) à exécuter")
+
+            for task in pending_tasks:
+                self.execute_task(task)
+
+    def execute_task(self, task):
+        """Exécute une tâche spécifique avec logging complet"""
+        print(f"\n[{datetime.now(timezone.utc)}] Exécution de: {task.name}")
+
+        with self.app.app_context():
+            execution_log = TaskExecutionLog(
+                task_id=task.id,
+                task_name=task.name,
+                server_hostname=self.hostname,
+                process_id=self.pid,
+            )
+            db.session.add(execution_log)
+            task.mark_running()
+            execution_log.status = "running"
+            db.session.commit()
+
+            try:
+                output = self.run_task_function(task.name)
+
+                execution_log.status = "success"
+                execution_log.completed_at = datetime.now(timezone.utc)
+                execution_log.output_log = output
+                task.mark_success()
+
+                print(f"  ✓ {task.name} terminé avec succès")
+
+            except Exception as e:
+                error_msg = f"{str(e)}\n{traceback.format_exc()}"
+
+                execution_log.status = "failed"
+                execution_log.completed_at = datetime.now(timezone.utc)
+                execution_log.error_message = error_msg[:2000]
+                task.mark_failed(str(e))
+
+                print(f"  ✗ {task.name} a échoué: {str(e)}")
+
+            db.session.commit()
+
+    def run_task_function(self, task_name):
+        """Exécute la fonction associée au nom de la tâche"""
+        f = StringIO()
+
+        with redirect_stdout(f):
+            if task_name == "daily_gains":
+                self._run_daily_gains()
+            elif task_name == "hourly_cleanup":
+                self._run_hourly_cleanup()
+            elif task_name == "weekly_report":
+                self._run_weekly_report()
+            else:
+                raise ValueError(f"Tâche inconnue: {task_name}")
+
+        return f.getvalue()
+
+    def _run_daily_gains(self):
+        """Calcule les gains quotidiens et traite les commissions"""
+        from scripts.daily_gains import (
+            calculate_daily_gains,
+            auto_process_withdrawals,
+            cleanup_old_notifications,
+            print_platform_summary,
+        )
+
+        calculate_daily_gains()
+        auto_process_withdrawals()
+        cleanup_old_notifications()
+        print_platform_summary()
+
+    def _run_hourly_cleanup(self):
+        """Nettoyage périodique"""
+        print("Nettoyage horaire...")
+        from scripts.daily_gains import cleanup_old_notifications
+
+        cleanup_old_notifications()
+        print("Nettoyage terminé")
+
+    def _run_weekly_report(self):
+        """Rapport hebdomadaire"""
+        print("Génération du rapport hebdomadaire...")
+        print("TODO: Implémenter le rapport hebdomadaire")
+
+    def check_missed_tasks(self):
+        """Vérifie et exécute les tâches manquées depuis le dernier démarrage"""
+        with self.app.app_context():
+            now = datetime.now(timezone.utc)
+
+            missed_tasks = ScheduledTask.query.filter(
+                ScheduledTask.is_active == True,
+                db.or_(
+                    ScheduledTask.last_run_at.is_(None),
+                    ScheduledTask.last_run_at < now - timedelta(hours=25),
+                ),
+            ).all()
+
+            if missed_tasks:
+                print(f"\n⚠️  {len(missed_tasks)} tâche(s) manquée(s) détectée(s)!")
+                for task in missed_tasks:
+                    last_run = (
+                        task.last_run_at.strftime("%Y-%m-%d %H:%M")
+                        if task.last_run_at
+                        else "JAMAIS"
+                    )
+                    print(f"   - {task.name} (dernier run: {last_run})")
+                    self.execute_task(task)
+            else:
+                print(f"\n✓ Aucune tâche manquée")
+
+    def initialize_default_tasks(self):
+        """Crée les tâches par défaut si elles n'existent pas"""
+        with self.app.app_context():
+            default_tasks = [
+                {
+                    "name": "daily_gains",
+                    "description": "Calcule les gains quotidiens, traite les retraits et commissions",
+                    "schedule_type": "daily",
+                    "schedule_time": time(0, 5, 0),
+                    "is_active": True,
+                },
+                {
+                    "name": "hourly_cleanup",
+                    "description": "Nettoyage des notifications et logs anciens",
+                    "schedule_type": "hourly",
+                    "is_active": True,
+                },
+            ]
+
+            for task_data in default_tasks:
+                existing = ScheduledTask.query.filter_by(name=task_data["name"]).first()
+                if not existing:
+                    task = ScheduledTask(**task_data)
+                    task.calculate_next_run()
+                    db.session.add(task)
+                    print(f"✓ Tâche créée: {task_data['name']}")
+
+            db.session.commit()
+
+    def print_status(self):
+        """Affiche le statut de toutes les tâches"""
+        with self.app.app_context():
+            tasks = ScheduledTask.query.all()
+
+            print("\n" + "=" * 70)
+            print("STATUT DES TÂCHES PLANIFIÉES")
+            print("=" * 70)
+
+            for task in tasks:
+                status_icon = (
+                    "✓"
+                    if task.last_status == "success"
+                    else "✗"
+                    if task.last_status == "failed"
+                    else "○"
+                )
+                next_run = (
+                    task.next_run_at.strftime("%d/%m %H:%M")
+                    if task.next_run_at
+                    else "Non calculé"
+                )
+                last_run = (
+                    task.last_run_at.strftime("%d/%m %H:%M")
+                    if task.last_run_at
+                    else "Jamais"
+                )
+
+                print(
+                    f"{status_icon} {task.name:20} | Prochain: {next_run:12} | Dernier: {last_run:12} | Runs: {task.run_count}"
+                )
+
+            print("=" * 70)
+
+
+def run_scheduler_daemon():
+    """Mode daemon - boucle infinie qui vérifie chaque minute"""
+    runner = TaskRunner()
+
+    print("=" * 70)
+    print("SCHEDULER DB-BASED - MODE DAEMON")
+    print(f"Démarré à: {datetime.now(timezone.utc)}")
+    print(f"Hostname: {runner.hostname} | PID: {runner.pid}")
+    print("=" * 70)
+
+    runner.initialize_default_tasks()
+    runner.check_missed_tasks()
+    runner.print_status()
+
+    print("\nEn attente des tâches... (Ctrl+C pour arrêter)\n")
+
+    try:
+        while True:
+            runner.run_pending_tasks()
+            import time
+
+            time.sleep(60)
+    except KeyboardInterrupt:
+        print("\n\nArrêt du scheduler.")
+        print(f"Terminé à: {datetime.now(timezone.utc)}")
+
+
+def run_scheduler_once():
+    """Mode one-shot - une seule exécution puis sortie"""
+    runner = TaskRunner()
+
+    print("=" * 70)
+    print("SCHEDULER DB-BASED - MODE ONE-SHOT")
+    print(f"Exécution à: {datetime.now(timezone.utc)}")
+    print("=" * 70)
+
+    runner.initialize_default_tasks()
+    runner.check_missed_tasks()
+    runner.run_pending_tasks()
+    runner.print_status()
+
+    print("\nExécution terminée.")
+
+
+def check_and_run_missed_on_startup():
+    """Vérifie les tâches manquées au démarrage de l'app (non bloquant)"""
+    try:
+        runner = TaskRunner()
+        runner.initialize_default_tasks()
+        runner.check_missed_tasks()
+    except Exception as e:
+        print(f"[Scheduler] Erreur lors de la vérification des tâches: {e}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1 and sys.argv[1] == "--daemon":
+        run_scheduler_daemon()
+    else:
+        run_scheduler_once()

app/templates/admin/base.html

@@ -134,6 +134,14 @@
                             <i class="fas fa-sliders-h w-5 mr-3"></i>
                             Paramètres Généraux
                         </a>
+
+                        <a
+                            href="{{ url_for('admin_tasks.list_tasks') }}"
+                            class="sidebar-link flex items-center px-4 py-3 rounded-lg border-l-4 border-transparent text-gray-300 hover:text-yellow-400 {% if 'tasks' in request.endpoint %}active{% endif %}"
+                        >
+                            <i class="fas fa-clock w-5 mr-3"></i>
+                            Tâches Planifiées
+                        </a>
                     </div>
                 </nav>
 

app/templates/admin/task_logs.html

@@ -0,0 +1,129 @@
+{% extends "admin/base.html" %}
+
+{% block title %}Logs des Tâches{% endblock %}
+{% block page_title %}Logs des Tâches{% endblock %}
+
+{% block content %}
+<div class="space-y-6">
+    <!-- Header avec navigation -->
+    <div class="flex justify-between items-center">
+        <h3 class="text-lg font-semibold text-white">Historique des Exécutions</h3>
+        <a href="{{ url_for('admin_tasks.list_tasks') }}" class="px-4 py-2 bg-gray-700 hover:bg-gray-600 text-white rounded-lg text-sm">
+            <i class="fas fa-arrow-left mr-2"></i>Retour aux Tâches
+        </a>
+    </div>
+
+    <!-- Logs -->
+    <div class="bg-gray-800 rounded-lg border border-gray-700">
+        <div class="overflow-x-auto">
+            <table class="w-full text-left">
+                <thead class="bg-gray-700/50">
+                    <tr>
+                        <th class="px-6 py-3 text-sm font-medium text-gray-300">Date</th>
+                        <th class="px-6 py-3 text-sm font-medium text-gray-300">Tâche</th>
+                        <th class="px-6 py-3 text-sm font-medium text-gray-300">Statut</th>
+                        <th class="px-6 py-3 text-sm font-medium text-gray-300">Durée</th>
+                        <th class="px-6 py-3 text-sm font-medium text-gray-300">Serveur</th>
+                        <th class="px-6 py-3 text-sm font-medium text-gray-300">Détails</th>
+                    </tr>
+                </thead>
+                <tbody class="divide-y divide-gray-700">
+                    {% for log in logs.items %}
+                    <tr class="hover:bg-gray-700/30">
+                        <td class="px-6 py-4 text-sm text-gray-300">
+                            {{ log.started_at.strftime('%d/%m/%Y %H:%M:%S') }}
+                        </td>
+                        <td class="px-6 py-4 text-sm font-medium text-white">
+                            {{ log.task_name }}
+                        </td>
+                        <td class="px-6 py-4">
+                            {% if log.status == 'success' %}
+                                <span class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-green-500/20 text-green-400">
+                                    <i class="fas fa-check mr-1"></i> Succès
+                                </span>
+                            {% elif log.status == 'failed' %}
+                                <span class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-red-500/20 text-red-400">
+                                    <i class="fas fa-times mr-1"></i> Échec
+                                </span>
+                            {% else %}
+                                <span class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-blue-500/20 text-blue-400">
+                                    <i class="fas fa-spinner fa-spin mr-1"></i> En cours
+                                </span>
+                            {% endif %}
+                        </td>
+                        <td class="px-6 py-4 text-sm text-gray-300">
+                            {% if log.completed_at %}
+                                {% set duration = (log.completed_at - log.started_at).total_seconds() // 60 %}
+                                {% if duration > 0 %}
+                                    {{ duration|int }} min
+                                {% else %}
+                                    {{ ((log.completed_at - log.started_at).total_seconds())|int }} s
+                                {% endif %}
+                            {% else %}
+                                -
+                            {% endif %}
+                        </td>
+                        <td class="px-6 py-4 text-sm text-gray-400">
+                            {{ log.server_hostname or 'N/A' }}
+                            <br><span class="text-xs">PID: {{ log.process_id or 'N/A' }}</span>
+                        </td>
+                        <td class="px-6 py-4 text-sm text-gray-300">
+                            {% if log.error_message %}
+                                <div class="max-w-xs">
+                                    <p class="text-red-400 text-xs truncate">{{ log.error_message[:100] }}</p>
+                                </div>
+                            {% elif log.output_log %}
+                                <div class="max-w-xs">
+                                    <p class="text-xs text-gray-400 truncate">{{ log.output_log[:100] }}</p>
+                                </div>
+                            {% else %}
+                                <span class="text-gray-500">-</span>
+                            {% endif %}
+                        </td>
+                    </tr>
+                    {% if log.error_message or log.output_log %}
+                    <tr class="bg-gray-700/20">
+                        <td colspan="6" class="px-6 py-3">
+                            {% if log.error_message %}
+                            <div class="mb-2">
+                                <p class="text-xs font-semibold text-red-400 mb-1">Erreur:</p>
+                                <pre class="text-xs text-red-300 bg-red-900/20 p-2 rounded overflow-x-auto">{{ log.error_message }}</pre>
+                            </div>
+                            {% endif %}
+                            {% if log.output_log %}
+                            <div>
+                                <p class="text-xs font-semibold text-gray-400 mb-1">Sortie:</p>
+                                <pre class="text-xs text-gray-300 bg-gray-700/50 p-2 rounded overflow-x-auto max-h-40 overflow-y-auto">{{ log.output_log }}</pre>
+                            </div>
+                            {% endif %}
+                        </td>
+                    </tr>
+                    {% endif %}
+                    {% endfor %}
+                </tbody>
+            </table>
+        </div>
+
+        <!-- Pagination -->
+        {% if logs.pages > 1 %}
+        <div class="px-6 py-4 border-t border-gray-700 flex justify-between items-center">
+            <p class="text-sm text-gray-400">
+                Page {{ logs.page }} sur {{ logs.pages }}
+            </p>
+            <div class="flex space-x-2">
+                {% if logs.has_prev %}
+                <a href="{{ url_for('admin_tasks.view_logs', page=logs.prev_num) }}" class="px-3 py-1 bg-gray-700 hover:bg-gray-600 text-white rounded text-sm">
+                    <i class="fas fa-chevron-left"></i> Précédent
+                </a>
+                {% endif %}
+                {% if logs.has_next %}
+                <a href="{{ url_for('admin_tasks.view_logs', page=logs.next_num) }}" class="px-3 py-1 bg-gray-700 hover:bg-gray-600 text-white rounded text-sm">
+                    Suivant <i class="fas fa-chevron-right"></i>
+                </a>
+                {% endif %}
+            </div>
+        </div>
+        {% endif %}
+    </div>
+</div>
+{% endblock %}

app/templates/admin/tasks.html

@@ -0,0 +1,193 @@
+{% extends "admin/base.html" %}
+
+{% block title %}Tâches Planifiées{% endblock %}
+{% block page_title %}Tâches Planifiées{% endblock %}
+
+{% block content %}
+<div class="space-y-6">
+    <!-- Statistiques -->
+    <div class="grid grid-cols-1 md:grid-cols-4 gap-4">
+        <div class="bg-gray-800 rounded-lg p-4 border border-gray-700">
+            <div class="flex items-center">
+                <div class="p-3 rounded-full bg-blue-500/20 text-blue-400">
+                    <i class="fas fa-tasks text-xl"></i>
+                </div>
+                <div class="ml-4">
+                    <p class="text-sm text-gray-400">Total Tâches</p>
+                    <p class="text-2xl font-bold text-white">{{ stats.total }}</p>
+                </div>
+            </div>
+        </div>
+
+        <div class="bg-gray-800 rounded-lg p-4 border border-gray-700">
+            <div class="flex items-center">
+                <div class="p-3 rounded-full bg-green-500/20 text-green-400">
+                    <i class="fas fa-play text-xl"></i>
+                </div>
+                <div class="ml-4">
+                    <p class="text-sm text-gray-400">Actives</p>
+                    <p class="text-2xl font-bold text-white">{{ stats.active }}</p>
+                </div>
+            </div>
+        </div>
+
+        <div class="bg-gray-800 rounded-lg p-4 border border-gray-700">
+            <div class="flex items-center">
+                <div class="p-3 rounded-full bg-yellow-500/20 text-yellow-400">
+                    <i class="fas fa-clock text-xl"></i>
+                </div>
+                <div class="ml-4">
+                    <p class="text-sm text-gray-400">En Attente</p>
+                    <p class="text-2xl font-bold text-white">{{ stats.pending }}</p>
+                </div>
+            </div>
+        </div>
+
+        <div class="bg-gray-800 rounded-lg p-4 border border-gray-700">
+            <div class="flex items-center">
+                <div class="p-3 rounded-full bg-red-500/20 text-red-400">
+                    <i class="fas fa-exclamation-triangle text-xl"></i>
+                </div>
+                <div class="ml-4">
+                    <p class="text-sm text-gray-400">Échecs</p>
+                    <p class="text-2xl font-bold text-white">{{ stats.failed }}</p>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Table des tâches -->
+    <div class="bg-gray-800 rounded-lg border border-gray-700">
+        <div class="p-6 border-b border-gray-700 flex justify-between items-center">
+            <h3 class="text-lg font-semibold text-white">Liste des Tâches</h3>
+            <a href="{{ url_for('admin_tasks.view_logs') }}" class="px-4 py-2 bg-blue-600 hover:bg-blue-700 text-white rounded-lg text-sm">
+                <i class="fas fa-history mr-2"></i>Voir les Logs
+            </a>
+        </div>
+        <div class="overflow-x-auto">
+            <table class="w-full text-left">
+                <thead class="bg-gray-700/50">
+                    <tr>
+                        <th class="px-6 py-3 text-sm font-medium text-gray-300">Nom</th>
+                        <th class="px-6 py-3 text-sm font-medium text-gray-300">Planning</th>
+                        <th class="px-6 py-3 text-sm font-medium text-gray-300">Statut</th>
+                        <th class="px-6 py-3 text-sm font-medium text-gray-300">Dernier Run</th>
+                        <th class="px-6 py-3 text-sm font-medium text-gray-300">Prochain Run</th>
+                        <th class="px-6 py-3 text-sm font-medium text-gray-300">Actions</th>
+                    </tr>
+                </thead>
+                <tbody class="divide-y divide-gray-700">
+                    {% for task in tasks %}
+                    <tr class="hover:bg-gray-700/30 {% if task.should_run() %}bg-yellow-500/10{% endif %}">
+                        <td class="px-6 py-4">
+                            <div class="flex items-center">
+                                <div>
+                                    <p class="text-sm font-medium text-white">{{ task.name }}</p>
+                                    <p class="text-xs text-gray-400">{{ task.description }}</p>
+                                    {% if task.should_run() %}
+                                    <span class="inline-flex items-center px-2 py-0.5 rounded text-xs font-medium bg-yellow-500/20 text-yellow-400 mt-1">
+                                        À exécuter!
+                                    </span>
+                                    {% endif %}
+                                </div>
+                            </div>
+                        </td>
+                        <td class="px-6 py-4 text-sm text-gray-300">
+                            {% if task.schedule_type == 'daily' %}
+                                Quotidien à {{ task.schedule_time.strftime('%H:%M') }}
+                            {% elif task.schedule_type == 'hourly' %}
+                                Toutes les heures
+                            {% else %}
+                                Tous les {{ task.interval_minutes }} min
+                            {% endif %}
+                        </td>
+                        <td class="px-6 py-4">
+                            {% if task.last_status == 'success' %}
+                                <span class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-green-500/20 text-green-400">
+                                    <i class="fas fa-check mr-1"></i> Succès
+                                </span>
+                            {% elif task.last_status == 'failed' %}
+                                <span class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-red-500/20 text-red-400">
+                                    <i class="fas fa-times mr-1"></i> Échec
+                                </span>
+                            {% elif task.last_status == 'running' %}
+                                <span class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-blue-500/20 text-blue-400">
+                                    <i class="fas fa-spinner fa-spin mr-1"></i> En cours
+                                </span>
+                            {% else %}
+                                <span class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-gray-500/20 text-gray-400">
+                                    En attente
+                                </span>
+                            {% endif %}
+                        </td>
+                        <td class="px-6 py-4 text-sm text-gray-300">
+                            {% if task.last_run_at %}
+                                {{ task.last_run_at.strftime('%d/%m/%Y %H:%M') }}
+                                <br><span class="text-xs text-gray-500">{{ task.run_count }} runs</span>
+                            {% else %}
+                                <span class="text-gray-500">Jamais</span>
+                            {% endif %}
+                        </td>
+                        <td class="px-6 py-4 text-sm text-gray-300">
+                            {% if task.next_run_at %}
+                                {{ task.next_run_at.strftime('%d/%m/%Y %H:%M') }}
+                            {% else %}
+                                <span class="text-gray-500">Non calculé</span>
+                            {% endif %}
+                        </td>
+                        <td class="px-6 py-4">
+                            <div class="flex space-x-2">
+                                <form method="POST" action="{{ url_for('admin_tasks.run_task_now', task_id=task.id) }}" class="inline">
+                                    <button type="submit" class="px-3 py-1 bg-blue-600 hover:bg-blue-700 text-white rounded text-sm" title="Exécuter maintenant">
+                                        <i class="fas fa-play"></i>
+                                    </button>
+                                </form>
+                                <form method="POST" action="{{ url_for('admin_tasks.toggle_task', task_id=task.id) }}" class="inline">
+                                    <button type="submit" class="px-3 py-1 {% if task.is_active %}bg-gray-600 hover:bg-gray-700{% else %}bg-green-600 hover:bg-green-700{% endif %} text-white rounded text-sm" title="{{ 'Désactiver' if task.is_active else 'Activer' }}">
+                                        <i class="fas {% if task.is_active %}fa-pause{% else %}fa-play{% endif %}"></i>
+                                    </button>
+                                </form>
+                            </div>
+                        </td>
+                    </tr>
+                    {% if task.last_error %}
+                    <tr class="bg-red-500/5">
+                        <td colspan="6" class="px-6 py-2">
+                            <p class="text-xs text-red-400">
+                                <i class="fas fa-exclamation-circle mr-1"></i>
+                                <strong>Erreur:</strong> {{ task.last_error[:200] }}{% if task.last_error|length > 200 %}...{% endif %}
+                            </p>
+                        </td>
+                    </tr>
+                    {% endif %}
+                    {% endfor %}
+                </tbody>
+            </table>
+        </div>
+    </div>
+
+    <!-- Info -->
+    <div class="bg-blue-900/30 border border-blue-700 rounded-lg p-4">
+        <div class="flex items-start">
+            <i class="fas fa-info-circle text-blue-400 mt-0.5 mr-3"></i>
+            <div>
+                <h4 class="text-sm font-medium text-blue-300">À propos du Scheduler</h4>
+                <p class="text-sm text-blue-200 mt-1">
+                    Ce système remplace les cron jobs traditionnels. Les tâches sont stockées en base de données
+                    et peuvent être exécutées manuellement ou automatiquement. Si le serveur redémarre,
+                    les tâches manquées seront automatiquement rattrapées.
+                </p>
+            </div>
+        </div>
+    </div>
+</div>
+{% endblock %}
+
+{% block scripts %}
+<script>
+    // Auto-refresh toutes les 30 secondes pour voir les mises à jour en temps réel
+    setInterval(function() {
+        window.location.reload();
+    }, 30000);
+</script>
+{% endblock %}

docker-compose.yml

@@ -0,0 +1,23 @@
+version: '3.8'
+
+services:
+  apex-ores:
+    build: .
+    container_name: apex-ores
+    ports:
+      - "7860:7860"
+    volumes:
+      # Persister la base de données SQLite
+      - ./instance:/app/instance
+      # Persister les logs
+      - ./logs:/var/log/apex
+    environment:
+      - FLASK_ENV=production
+      - PYTHONPATH=/app
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:7860/"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s