notytex/DOMAINES_IMPLEMENTATION_PLAN.md

🎯 Plan d'Implémentation - Domaines pour Éléments de Notation

📋 Vue d'Ensemble

L'ajout de la fonctionnalité "domaine" aux éléments de notation permettra de catégoriser et taguer les éléments d'évaluation. Les domaines seront assignables depuis une liste existante ou créés dynamiquement lors de la saisie.

🗄️ Phase 1 : Modèle de Données et Migration

1.1 Création du modèle Domain

Fichier : models.py (ligne 346+)

class Domain(db.Model):
    """Domaines/tags pour les éléments de notation."""
    __tablename__ = 'domains'
    
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), unique=True, nullable=False)
    color = db.Column(db.String(7), nullable=False, default='#6B7280')  # Format #RRGGBB
    description = db.Column(db.Text)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    # Relation inverse
    grading_elements = db.relationship('GradingElement', backref='domain', lazy=True)
    
    def __repr__(self):
        return f'<Domain {self.name}>'

1.2 Modification du modèle GradingElement

Fichier : models.py (ligne 284 - après skill)

# Ajout du champ domain_id
domain_id = db.Column(db.Integer, db.ForeignKey('domains.id'), nullable=True)  # Optionnel

1.3 Script de migration de base de données

Nouveau fichier : migrations/add_domains.py

"""Migration pour ajouter les domaines aux éléments de notation."""

def upgrade():
    # Créer la table domains
    op.create_table('domains',
        sa.Column('id', sa.Integer, primary_key=True),
        sa.Column('name', sa.String(100), nullable=False, unique=True),
        sa.Column('color', sa.String(7), nullable=False, default='#6B7280'),
        sa.Column('description', sa.Text),
        sa.Column('created_at', sa.DateTime, default=datetime.utcnow),
        sa.Column('updated_at', sa.DateTime, default=datetime.utcnow)
    )
    
    # Ajouter la colonne domain_id à grading_element
    op.add_column('grading_element', 
        sa.Column('domain_id', sa.Integer, sa.ForeignKey('domains.id'), nullable=True)
    )

def downgrade():
    op.drop_column('grading_element', 'domain_id')
    op.drop_table('domains')

⚙️ Phase 2 : Configuration et Initialisation

2.1 Domaines par défaut dans la configuration

Fichier : app_config.py (ligne 134 - dans default_config)

'domains': {
    'default_domains': [
        {
            'name': 'Algèbre',
            'color': '#3b82f6',
            'description': 'Calculs algébriques, équations, expressions'
        },
        {
            'name': 'Géométrie',
            'color': '#10b981',
            'description': 'Figures, mesures, constructions géométriques'
        },
        {
            'name': 'Statistiques',
            'color': '#f59e0b',
            'description': 'Données, moyennes, graphiques statistiques'
        },
        {
            'name': 'Fonctions',
            'color': '#8b5cf6',
            'description': 'Fonctions, graphiques, tableaux de valeurs'
        },
        {
            'name': 'Problèmes',
            'color': '#ef4444',
            'description': 'Résolution de problèmes concrets'
        },
        {
            'name': 'Calcul mental',
            'color': '#06b6d4',
            'description': 'Calculs rapides, estimations'
        }
    ]
}

2.2 Méthodes de gestion des domaines dans ConfigManager

Fichier : app_config.py (ligne 504+)

def get_domains_list(self) -> List[Dict[str, Any]]:
    """Récupère la liste des domaines configurés."""
    domains = Domain.query.order_by(Domain.name).all()
    return [
        {
            'id': domain.id,
            'name': domain.name,
            'color': domain.color,
            'description': domain.description or ''
        }
        for domain in domains
    ]

def add_domain(self, name: str, color: str = '#6B7280', description: str = '') -> bool:
    """Ajoute un nouveau domaine."""
    try:
        domain = Domain(name=name, color=color, description=description)
        db.session.add(domain)
        db.session.commit()
        return True
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"Erreur lors de l'ajout du domaine: {e}")
        return False

def get_or_create_domain(self, name: str, color: str = '#6B7280') -> Domain:
    """Récupère un domaine existant ou le crée s'il n'existe pas."""
    domain = Domain.query.filter_by(name=name).first()
    if not domain:
        domain = Domain(name=name, color=color)
        db.session.add(domain)
        db.session.commit()
    return domain

2.3 Initialisation des domaines par défaut

Fichier : app_config.py (ligne 176 - dans initialize_default_config)

# Domaines par défaut
if Domain.query.count() == 0:
    default_domains = self.default_config['domains']['default_domains']
    for domain_data in default_domains:
        domain = Domain(
            name=domain_data['name'],
            color=domain_data['color'],
            description=domain_data.get('description', '')
        )
        db.session.add(domain)

2.4 Modification du script d'initialisation

Fichier : commands.py (ligne 3 - import)

from models import db, ClassGroup, Student, Assessment, Exercise, GradingElement, Domain

Fichier : commands.py (ligne 66-80 - modification des données d'exemple)

# Récupérer ou créer des domaines pour les exemples
domain_calcul = Domain.query.filter_by(name='Algèbre').first()
domain_methode = Domain.query.filter_by(name='Problèmes').first()
domain_presentation = Domain.query.filter_by(name='Communication').first()

if not domain_calcul:
    domain_calcul = Domain(name='Algèbre', color='#3b82f6')
    db.session.add(domain_calcul)
    db.session.commit()

elements_data = [
    ("Calcul de base", "Addition et soustraction de fractions", "Calculer", 4.0, "notes", domain_calcul.id),
    ("Méthode", "Justification de la méthode utilisée", "Raisonner", 2.0, "score", domain_methode.id),
    ("Présentation", "Clarté de la présentation", "Communiquer", 2.0, "score", domain_presentation.id),
]

for label, description, skill, max_points, grading_type, domain_id in elements_data:
    element = GradingElement(
        exercise_id=exercise.id,
        label=label,
        description=description,
        skill=skill,
        max_points=max_points,
        grading_type=grading_type,
        domain_id=domain_id
    )
    db.session.add(element)

🌐 Phase 3 : API et Routes

3.1 Nouvelles routes pour les domaines

Nouveau fichier : routes/domains.py

from flask import Blueprint, jsonify, request, current_app
from models import db, Domain
from app_config import config_manager
from utils import handle_db_errors

bp = Blueprint('domains', __name__, url_prefix='/api/domains')

@bp.route('/', methods=['GET'])
@handle_db_errors
def list_domains():
    """Liste tous les domaines disponibles."""
    domains = config_manager.get_domains_list()
    return jsonify({'success': True, 'domains': domains})

@bp.route('/', methods=['POST'])
@handle_db_errors
def create_domain():
    """Crée un nouveau domaine dynamiquement."""
    data = request.get_json()
    
    if not data or not data.get('name'):
        return jsonify({'success': False, 'error': 'Nom du domaine requis'}), 400
    
    name = data['name'].strip()
    color = data.get('color', '#6B7280')
    description = data.get('description', '')
    
    # Vérifier que le domaine n'existe pas déjà
    if Domain.query.filter_by(name=name).first():
        return jsonify({'success': False, 'error': 'Un domaine avec ce nom existe déjà'}), 400
    
    success = config_manager.add_domain(name, color, description)
    
    if success:
        # Récupérer le domaine créé
        domain = Domain.query.filter_by(name=name).first()
        return jsonify({
            'success': True, 
            'domain': {
                'id': domain.id,
                'name': domain.name,
                'color': domain.color,
                'description': domain.description or ''
            }
        })
    else:
        return jsonify({'success': False, 'error': 'Erreur lors de la création du domaine'}), 500

@bp.route('/search', methods=['GET'])
@handle_db_errors
def search_domains():
    """Recherche des domaines par nom (pour auto-complétion)."""
    query = request.args.get('q', '').strip()
    
    if len(query) < 2:
        return jsonify({'success': True, 'domains': []})
    
    domains = Domain.query.filter(
        Domain.name.ilike(f'%{query}%')
    ).order_by(Domain.name).limit(10).all()
    
    results = [
        {
            'id': domain.id,
            'name': domain.name,
            'color': domain.color,
            'description': domain.description or ''
        }
        for domain in domains
    ]
    
    return jsonify({'success': True, 'domains': results})

3.2 Enregistrement des routes des domaines

Fichier : routes/__init__.py

from . import domains

def register_blueprints(app):
    # ... routes existantes ...
    app.register_blueprint(domains.bp)

3.3 Modification du service Assessment

Fichier : services.py (modification de process_assessment_with_exercises)

# Dans la boucle de traitement des grading_elements
for elem_data in exercise_data.get('grading_elements', []):
    # ... code existant ...
    
    # Gestion du domaine
    domain_id = None
    if 'domain_name' in elem_data and elem_data['domain_name']:
        # Récupérer ou créer le domaine
        domain = config_manager.get_or_create_domain(
            elem_data['domain_name'], 
            elem_data.get('domain_color', '#6B7280')
        )
        domain_id = domain.id
    elif 'domain_id' in elem_data:
        domain_id = elem_data['domain_id']
    
    if is_edit and 'id' in elem_data:
        # Modification d'un élément existant
        element.domain_id = domain_id
    else:
        # Création d'un nouvel élément
        element = GradingElement(
            # ... paramètres existants ...
            domain_id=domain_id
        )

🎨 Phase 4 : Interface Utilisateur

4.1 Modification du template de création/édition

Fichier : templates/assessment_form_unified.html (ligne 252 - après le champ compétence)

<div>
    <label class="block text-xs font-medium text-gray-700 mb-1">Domaine</label>
    <div class="relative">
        <select class="element-domain-id block w-full border border-gray-300 rounded-md px-2 py-1 text-sm focus:ring-purple-500 focus:border-purple-500">
            <option value="">Non spécifié</option>
            {% for domain in domains %}
                <option value="{{ domain.id }}" data-color="{{ domain.color }}">
                    {{ domain.name }}
                </option>
            {% endfor %}
        </select>
        <div class="absolute inset-y-0 right-8 flex items-center">
            <button type="button" class="create-domain-btn text-xs text-blue-600 hover:text-blue-800 font-medium px-2">
                + Créer
            </button>
        </div>
    </div>
    <input type="text" class="element-domain-name hidden domain-input block w-full border border-gray-300 rounded-md px-2 py-1 text-sm focus:ring-purple-500 focus:border-purple-500" placeholder="Nouveau domaine...">
</div>

4.2 JavaScript pour la gestion des domaines

Fichier : templates/assessment_form_unified.html (dans la section script)

// Gestion des domaines
let availableDomains = [];

// Charger les domaines disponibles
async function loadDomains() {
    try {
        const response = await fetch('/api/domains/');
        const data = await response.json();
        if (data.success) {
            availableDomains = data.domains;
        }
    } catch (error) {
        console.error('Erreur lors du chargement des domaines:', error);
    }
}

// Ajouter la gestion du bouton "Créer domaine"
function setupDomainCreation(container) {
    const createBtn = container.querySelector('.create-domain-btn');
    const selectElement = container.querySelector('.element-domain-id');
    const inputElement = container.querySelector('.element-domain-name');
    
    createBtn.addEventListener('click', function() {
        // Basculer entre select et input
        if (selectElement.classList.contains('hidden')) {
            // Retour au mode select
            selectElement.classList.remove('hidden');
            inputElement.classList.add('hidden');
            createBtn.textContent = '+ Créer';
        } else {
            // Passer au mode création
            selectElement.classList.add('hidden');
            inputElement.classList.remove('hidden');
            inputElement.focus();
            createBtn.textContent = 'Annuler';
        }
    });
    
    // Validation du nouveau domaine lors de la perte de focus
    inputElement.addEventListener('blur', async function() {
        const domainName = this.value.trim();
        if (domainName) {
            await createNewDomain(domainName, container);
        }
    });
}

// Créer un nouveau domaine via API
async function createNewDomain(name, container) {
    try {
        const response = await fetch('/api/domains/', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'X-CSRFToken': document.querySelector('meta[name=csrf-token]').getAttribute('content')
            },
            body: JSON.stringify({
                name: name,
                color: generateRandomColor(),
                description: ''
            })
        });
        
        const data = await response.json();
        
        if (data.success) {
            // Ajouter le nouveau domaine à la liste
            availableDomains.push(data.domain);
            
            // Mettre à jour le select
            const selectElement = container.querySelector('.element-domain-id');
            const option = document.createElement('option');
            option.value = data.domain.id;
            option.textContent = data.domain.name;
            option.selected = true;
            selectElement.appendChild(option);
            
            // Revenir au mode select
            selectElement.classList.remove('hidden');
            container.querySelector('.element-domain-name').classList.add('hidden');
            container.querySelector('.create-domain-btn').textContent = '+ Créer';
            
            showNotification('Domaine créé avec succès !', 'success');
        } else {
            showNotification(data.error || 'Erreur lors de la création du domaine', 'error');
        }
    } catch (error) {
        console.error('Erreur:', error);
        showNotification('Erreur de connexion', 'error');
    }
}

function generateRandomColor() {
    const colors = ['#3b82f6', '#10b981', '#f59e0b', '#8b5cf6', '#ef4444', '#06b6d4', '#84cc16', '#f97316'];
    return colors[Math.floor(Math.random() * colors.length)];
}

// Initialiser au chargement
document.addEventListener('DOMContentLoaded', function() {
    loadDomains();
    // ... code existant ...
});

// Modifier la fonction addGradingElement pour inclure la gestion des domaines
function addGradingElement(exerciseContainer) {
    // ... code existant ...
    
    // Configurer la gestion des domaines pour ce nouvel élément
    setupDomainCreation(newElement);
    
    // ... reste du code ...
}

4.3 Passage des domaines aux templates

Fichier : routes/assessments.py (ligne 164 et 186)

# Dans la route edit (ligne 164)
competences = config_manager.get_competences_list()
domains = config_manager.get_domains_list()  # Ajouter cette ligne

return render_template('assessment_form_unified.html', 
                     form=form, 
                     title='Modifier l\'évaluation complète', 
                     assessment=assessment, 
                     exercises_json=exercises_data,
                     is_edit=True,
                     competences=competences,
                     domains=domains)  # Ajouter ce paramètre

# Dans la route new (ligne 186)
competences = config_manager.get_competences_list()
domains = config_manager.get_domains_list()  # Ajouter cette ligne

return render_template('assessment_form_unified.html', 
                     form=form, 
                     title='Nouvelle évaluation complète',
                     competences=competences,
                     domains=domains)  # Ajouter ce paramètre

4.4 Modification de la collecte des données du formulaire

Fichier : templates/assessment_form_unified.html (dans collectFormData)

function collectFormData() {
    // ... code existant pour assessment et exercises ...
    
    // Pour chaque grading element, ajouter le domaine
    gradingElements.forEach(element => {
        const domainSelect = element.querySelector('.element-domain-id');
        const domainInput = element.querySelector('.element-domain-name');
        
        if (!domainInput.classList.contains('hidden') && domainInput.value.trim()) {
            // Nouveau domaine à créer
            elementData.domain_name = domainInput.value.trim();
        } else if (domainSelect.value) {
            // Domaine existant sélectionné
            elementData.domain_id = parseInt(domainSelect.value);
        }
    });
}

📊 Phase 5 : Affichage et Visualisation

5.1 Affichage des domaines dans les vues d'évaluation

Fichier : templates/assessment_detail.html (modification de l'affichage des éléments)

<!-- Dans la boucle d'affichage des grading_elements -->
<div class="border border-gray-200 rounded p-3 bg-gray-50">
    <div class="flex justify-between items-start">
        <div class="flex-1">
            <h6 class="font-medium text-gray-900">{{ element.label }}</h6>
            <!-- Affichage du domaine s'il existe -->
            {% if element.domain %}
                <div class="mt-1">
                    <span class="inline-flex items-center px-2 py-0.5 rounded text-xs font-medium" 
                          style="background-color: {{ element.domain.color }}20; color: {{ element.domain.color }};">
                        {{ element.domain.name }}
                    </span>
                </div>
            {% endif %}
            {% if element.description %}
                <p class="text-sm text-gray-600 mt-1">{{ element.description }}</p>
            {% endif %}
        </div>
        <!-- ... reste de l'affichage ... -->
    </div>
</div>

5.2 Affichage des domaines dans la page de notation

Fichier : templates/assessment_grading.html (modification de l'affichage)

<!-- Dans l'en-tête de colonne des éléments de notation -->
<th class="px-3 py-2 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
    <div>
        {{ element.label }}
        {% if element.domain %}
            <div class="mt-1">
                <span class="inline-flex items-center px-1.5 py-0.5 rounded text-xs font-medium" 
                      style="background-color: {{ element.domain.color }}20; color: {{ element.domain.color }};">
                    {{ element.domain.name }}
                </span>
            </div>
        {% endif %}
    </div>
</th>

5.3 Statistiques par domaine dans les résultats

Fichier : models.py (nouvelle méthode dans Assessment)

def get_domain_statistics(self):
    """Calcule les statistiques par domaine pour cette évaluation."""
    from collections import defaultdict
    
    domain_stats = defaultdict(lambda: {
        'name': '',
        'color': '#6B7280',
        'total_points': 0,
        'elements_count': 0,
        'scores': []
    })
    
    students_scores, _ = self.calculate_student_scores()
    
    # Analyser chaque élément de notation
    for exercise in self.exercises:
        for element in exercise.grading_elements:
            domain_key = element.domain.name if element.domain else 'Non spécifié'
            
            if element.domain:
                domain_stats[domain_key]['name'] = element.domain.name
                domain_stats[domain_key]['color'] = element.domain.color
            
            domain_stats[domain_key]['total_points'] += element.max_points
            domain_stats[domain_key]['elements_count'] += 1
            
            # Calculer les scores des élèves pour cet élément
            for student in self.class_group.students:
                grade = Grade.query.filter_by(
                    student_id=student.id,
                    grading_element_id=element.id
                ).first()
                
                if grade and grade.value:
                    calculated_score = GradingCalculator.calculate_score(
                        grade.value.strip(), 
                        element.grading_type, 
                        element.max_points
                    )
                    if calculated_score is not None:
                        domain_stats[domain_key]['scores'].append(calculated_score)
    
    # Calculer les statistiques finales
    result = {}
    for domain_name, stats in domain_stats.items():
        if stats['scores']:
            import statistics
            result[domain_name] = {
                'name': stats['name'] or domain_name,
                'color': stats['color'],
                'total_points': stats['total_points'],
                'elements_count': stats['elements_count'],
                'students_count': len(set(stats['scores'])),  # Approximation
                'mean_score': round(statistics.mean(stats['scores']), 2),
                'success_rate': round(len([s for s in stats['scores'] if s > 0]) / len(stats['scores']) * 100, 1)
            }
    
    return result

5.4 Affichage des statistiques par domaine

Fichier : templates/assessment_results.html (nouvelle section)

<!-- Nouvelle section après les statistiques générales -->
<div class="bg-white shadow rounded-lg p-6 mb-8">
    <h2 class="text-lg font-medium text-gray-900 mb-4">📊 Analyse par domaine</h2>
    
    {% set domain_stats = assessment.get_domain_statistics() %}
    {% if domain_stats %}
        <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
            {% for domain_name, stats in domain_stats.items() %}
                <div class="border border-gray-200 rounded-lg p-4">
                    <div class="flex items-center mb-2">
                        <div class="w-4 h-4 rounded-full mr-2" style="background-color: {{ stats.color }};"></div>
                        <h3 class="font-medium text-gray-900">{{ stats.name }}</h3>
                    </div>
                    
                    <div class="space-y-1 text-sm text-gray-600">
                        <div>{{ stats.elements_count }} éléments</div>
                        <div>{{ stats.total_points }} points total</div>
                        <div>Moyenne : <span class="font-medium">{{ stats.mean_score }}</span></div>
                        <div>Taux de réussite : <span class="font-medium">{{ stats.success_rate }}%</span></div>
                    </div>
                </div>
            {% endfor %}
        </div>
    {% else %}
        <p class="text-gray-600">Aucun domaine défini pour cette évaluation.</p>
    {% endif %}
</div>

🛠️ Phase 6 : Administration des Domaines

6.1 Interface d'administration des domaines

Nouveau fichier : templates/config/domains.html

{% extends "base.html" %}

{% block title %}Configuration des Domaines - Gestion Scolaire{% endblock %}

{% block content %}
<div class="max-w-4xl mx-auto">
    <div class="mb-6">
        <h1 class="text-2xl font-bold text-gray-900">🏷️ Gestion des Domaines</h1>
        <p class="text-gray-600 mt-1">Configurez les domaines pour catégoriser vos éléments de notation</p>
    </div>
    
    <!-- Formulaire d'ajout -->
    <div class="bg-white shadow rounded-lg p-6 mb-8">
        <h2 class="text-lg font-medium text-gray-900 mb-4">Ajouter un nouveau domaine</h2>
        
        <form id="add-domain-form" class="grid grid-cols-1 md:grid-cols-3 gap-4">
            <div>
                <label class="block text-sm font-medium text-gray-700 mb-1">Nom du domaine</label>
                <input type="text" name="name" required 
                       class="block w-full border border-gray-300 rounded-md px-3 py-2 focus:ring-blue-500 focus:border-blue-500">
            </div>
            
            <div>
                <label class="block text-sm font-medium text-gray-700 mb-1">Couleur</label>
                <input type="color" name="color" value="#6B7280"
                       class="block w-full h-10 border border-gray-300 rounded-md focus:ring-blue-500 focus:border-blue-500">
            </div>
            
            <div class="flex items-end">
                <button type="submit" class="bg-blue-600 hover:bg-blue-700 text-white px-4 py-2 rounded-md font-medium">
                    Ajouter
                </button>
            </div>
        </form>
    </div>
    
    <!-- Liste des domaines existants -->
    <div class="bg-white shadow rounded-lg">
        <div class="px-6 py-4 border-b border-gray-200">
            <h2 class="text-lg font-medium text-gray-900">Domaines configurés</h2>
        </div>
        
        <div class="overflow-hidden">
            <table class="min-w-full divide-y divide-gray-200">
                <thead class="bg-gray-50">
                    <tr>
                        <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Domaine</th>
                        <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Utilisation</th>
                        <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Actions</th>
                    </tr>
                </thead>
                <tbody id="domains-table-body" class="bg-white divide-y divide-gray-200">
                    <!-- Contenu chargé en JavaScript -->
                </tbody>
            </table>
        </div>
    </div>
</div>

<script>
// JavaScript pour la gestion des domaines (formulaire, suppression, modification)
</script>
{% endblock %}

6.2 Route d'administration

Fichier : routes/config.py (ajout de la route)

@bp.route('/domains')
@handle_db_errors
def domains():
    """Page de configuration des domaines."""
    return render_template('config/domains.html')

6.3 API d'administration complète

Fichier : routes/domains.py (ajout des routes manquantes)

@bp.route('/<int:domain_id>', methods=['PUT'])
@handle_db_errors
def update_domain(domain_id):
    """Met à jour un domaine existant."""
    data = request.get_json()
    domain = Domain.query.get_or_404(domain_id)
    
    if data.get('name'):
        domain.name = data['name'].strip()
    if data.get('color'):
        domain.color = data['color']
    if 'description' in data:
        domain.description = data['description']
    
    try:
        db.session.commit()
        return jsonify({'success': True})
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"Erreur lors de la mise à jour du domaine: {e}")
        return jsonify({'success': False, 'error': 'Erreur lors de la sauvegarde'}), 500

@bp.route('/<int:domain_id>', methods=['DELETE'])
@handle_db_errors
def delete_domain(domain_id):
    """Supprime un domaine (si non utilisé)."""
    domain = Domain.query.get_or_404(domain_id)
    
    # Vérifier que le domaine n'est pas utilisé
    if domain.grading_elements:
        return jsonify({
            'success': False, 
            'error': f'Ce domaine est utilisé par {len(domain.grading_elements)} éléments de notation'
        }), 400
    
    try:
        db.session.delete(domain)
        db.session.commit()
        return jsonify({'success': True})
    except Exception as e:
        db.session.rollback()
        current_app.logger.error(f"Erreur lors de la suppression du domaine: {e}")
        return jsonify({'success': False, 'error': 'Erreur lors de la suppression'}), 500

@bp.route('/<int:domain_id>/usage', methods=['GET'])
@handle_db_errors
def domain_usage(domain_id):
    """Récupère les informations d'utilisation d'un domaine."""
    domain = Domain.query.get_or_404(domain_id)
    
    # Compter les éléments de notation utilisant ce domaine
    elements_count = len(domain.grading_elements)
    
    # Récupérer les évaluations concernées
    assessments = set()
    for element in domain.grading_elements:
        assessments.add(element.exercise.assessment)
    
    return jsonify({
        'success': True,
        'usage': {
            'elements_count': elements_count,
            'assessments_count': len(assessments),
            'assessments': [
                {
                    'id': assessment.id,
                    'title': assessment.title,
                    'class_name': assessment.class_group.name
                }
                for assessment in assessments
            ]
        }
    })

🧪 Phase 7 : Tests et Validation

7.1 Tests unitaires pour le modèle Domain

Nouveau fichier : tests/test_domains.py

import pytest
from models import Domain, GradingElement
from app_config import config_manager

class TestDomainModel:
    def test_create_domain(self, app_context):
        """Test de création d'un domaine."""
        domain = Domain(name="Test Domain", color="#FF0000")
        db.session.add(domain)
        db.session.commit()
        
        assert domain.id is not None
        assert domain.name == "Test Domain"
        assert domain.color == "#FF0000"

    def test_domain_grading_element_relationship(self, app_context, sample_data):
        """Test de la relation domain-grading_element."""
        domain = Domain(name="Math", color="#3b82f6")
        db.session.add(domain)
        db.session.commit()
        
        # Assigner le domaine à un élément de notation
        element = GradingElement.query.first()
        element.domain_id = domain.id
        db.session.commit()
        
        assert element.domain == domain
        assert domain.grading_elements[0] == element

class TestDomainAPI:
    def test_list_domains(self, client):
        """Test de l'API de liste des domaines."""
        response = client.get('/api/domains/')
        assert response.status_code == 200
        
        data = response.get_json()
        assert data['success'] is True
        assert 'domains' in data

    def test_create_domain_api(self, client):
        """Test de création de domaine via API."""
        payload = {
            'name': 'Nouveau Domaine',
            'color': '#FF5722',
            'description': 'Description test'
        }
        
        response = client.post('/api/domains/', 
                             json=payload,
                             headers={'X-CSRFToken': 'test-token'})
        
        assert response.status_code == 200
        data = response.get_json()
        assert data['success'] is True
        assert data['domain']['name'] == 'Nouveau Domaine'

7.2 Tests d'intégration

Fichier : tests/test_assessment_integration.py (ajout de tests)

def test_create_assessment_with_domains(client, app_context):
    """Test de création d'évaluation avec domaines."""
    # Créer un domaine
    domain = Domain(name="Géométrie", color="#10b981")
    db.session.add(domain)
    db.session.commit()
    
    # Données d'évaluation avec domaine
    assessment_data = {
        # ... données d'évaluation standard ...
        'exercises': [{
            'title': 'Exercice Géométrie',
            'grading_elements': [{
                'label': 'Calcul aire',
                'max_points': 5,
                'grading_type': 'notes',
                'domain_id': domain.id
            }]
        }]
    }
    
    response = client.post('/assessments/new', json=assessment_data)
    assert response.status_code == 200
    
    # Vérifier que le domaine est bien associé
    created_assessment = Assessment.query.first()
    element = created_assessment.exercises[0].grading_elements[0]
    assert element.domain_id == domain.id

📝 Phase 8 : Documentation et Finalisation

8.1 Mise à jour de CLAUDE.md

Fichier : CLAUDE.md (ajout dans la section Fonctionnalités)

### **Système de Domaines pour Éléments de Notation**
- **Catégorisation flexible** : Chaque élément de notation peut être associé à un domaine
- **Domaines configurables** : Liste de domaines prédéfinis modifiable (Algèbre, Géométrie, Statistiques...)
- **Création dynamique** : Possibilité de créer de nouveaux domaines à la volée lors de la saisie
- **Visualisation colorée** : Chaque domaine a une couleur pour faciliter la reconnaissance visuelle
- **Statistiques par domaine** : Analyse des résultats groupée par domaine dans la page de résultats
- **Interface d'administration** : Page dédiée pour gérer les domaines (création, modification, suppression)
- **Auto-complétion intelligente** : Suggestions basées sur les domaines existants lors de la saisie

8.2 Mise à jour du README technique

Section ajoutée au guide développeur :

## 🏷️ Système de Domaines

Les domaines permettent de catégoriser les éléments de notation. Implémentation:

### Modèles
- `Domain` : Domaines configurables avec nom, couleur, description
- `GradingElement.domain_id` : Relation optionnelle vers un domaine

### API
- `GET /api/domains/` : Liste des domaines
- `POST /api/domains/` : Création de domaine
- `GET /api/domains/search?q=term` : Recherche pour auto-complétion

### Configuration
```python
# Récupérer les domaines disponibles
domains = config_manager.get_domains_list()

# Créer/récupérer un domaine
domain = config_manager.get_or_create_domain('Algèbre', '#3b82f6')

## 🚀 **Calendrier de Mise en Œuvre**

| Phase | Durée estimée | Tâches principales |
|-------|---------------|-------------------|
| **Phase 1** | 2-3 jours | Modèle, migration, configuration |
| **Phase 2** | 1-2 jours | Configuration, initialisation |
| **Phase 3** | 2-3 jours | API, routes, services |
| **Phase 4** | 3-4 jours | Interface utilisateur, JavaScript |
| **Phase 5** | 2-3 jours | Affichage, statistiques |
| **Phase 6** | 2 jours | Administration |
| **Phase 7** | 2 jours | Tests |
| **Phase 8** | 1 jour | Documentation |

**Total estimé : 15-20 jours**

## ⚠️ **Points d'Attention**

1. **Migration de données** : S'assurer que les évaluations existantes continuent à fonctionner
2. **Performance** : Optimiser les requêtes lors de l'affichage des domaines
3. **Validation** : Empêcher la suppression de domaines utilisés
4. **UX** : Interface intuitive pour la création dynamique de domaines
5. **Sécurité** : Validation des données côté serveur pour la création de domaines

## ✅ **Critères de Validation**

- ✅ Création et modification d'évaluations avec domaines
- ✅ Affichage correct des domaines dans toutes les vues
- ✅ Création dynamique de domaines depuis l'interface
- ✅ Statistiques par domaine fonctionnelles
- ✅ Interface d'administration complète
- ✅ Tests unitaires et d'intégration passants
- ✅ Migration compatible avec les données existantes
- ✅ Performance acceptable avec beaucoup de domaines

Cette implémentation respecte l'architecture existante de Notytex et s'intègre naturellement dans le système de configuration et d'interface utilisateur actuels.