Formation SCORM pour Développeurs Full-Stack¶

// Structure d'un SCO
const sco = {
    identifier: "sco_001",
    title: "Introduction au JavaScript",
    launch: "index.html",
    resources: ["assets/", "scripts/", "styles/"],
    metadata: {
        description: "Module d'introduction au JavaScript",
        duration: "PT30M",
        difficulty: "beginner"
    }
};

class SCORMAPI {
    constructor() {
        this.api = null;
        this.connected = false;
        this.init();
    }

    init() {
        // Recherche de l'API SCORM
        if (window.parent && window.parent.API_1484_11) {
            this.api = window.parent.API_1484_11;
        } else if (window.parent && window.parent.API) {
            this.api = window.parent.API;
        } else if (window.API_1484_11) {
            this.api = window.API_1484_11;
        } else if (window.API) {
            this.api = window.API;
        }

        if (this.api) {
            this.connected = this.api.Initialize("");
        }
    }

    // Méthodes de base
    getValue(element) {
        if (this.connected) {
            return this.api.GetValue(element);
        }
        return null;
    }

    setValue(element, value) {
        if (this.connected) {
            return this.api.SetValue(element, value);
        }
        return false;
    }

    commit() {
        if (this.connected) {
            return this.api.Commit("");
        }
        return false;
    }

    terminate() {
        if (this.connected) {
            this.api.Terminate("");
            this.connected = false;
        }
    }
}

// Configuration du pack multi-SCO
const multiSCOConfig = {
    packageId: "formation_dev_web",
    version: "1.0",
    title: "Formation Développement Web Complète",
    scos: [
        {
            id: "html_basics",
            title: "HTML - Les Bases",
            launch: "html/index.html",
            prerequisites: [],
            masteryScore: 80,
            maxTimeAllowed: "PT45M"
        },
        {
            id: "css_basics", 
            title: "CSS - Les Bases",
            launch: "css/index.html",
            prerequisites: ["html_basics"],
            masteryScore: 75,
            maxTimeAllowed: "PT60M"
        },
        {
            id: "javascript_basics",
            title: "JavaScript - Les Bases", 
            launch: "js/index.html",
            prerequisites: ["html_basics", "css_basics"],
            masteryScore: 85,
            maxTimeAllowed: "PT90M"
        }
    ],
    sequencing: {
        controlMode: "choice",
        flowMode: "forward_only",
        rollupRules: {
            rollupObjectiveSatisfied: true,
            rollupProgressCompletion: true
        }
    }
};

class MultiSCOManager {
    constructor(config) {
        this.config = config;
        this.currentSCO = null;
        this.completedSCOs = [];
        this.progress = 0;
    }

    // Vérification des prérequis
    canAccessSCO(scoId) {
        const sco = this.config.scos.find(s => s.id === scoId);
        if (!sco) return false;

        return sco.prerequisites.every(prereq => 
            this.completedSCOs.includes(prereq)
        );
    }

    // Calcul de la progression globale
    calculateProgress() {
        const totalSCOs = this.config.scos.length;
        const completed = this.completedSCOs.length;
        this.progress = Math.round((completed / totalSCOs) * 100);
        return this.progress;
    }

    // Sauvegarde de la progression
    saveProgress() {
        const progressData = {
            completedSCOs: this.completedSCOs,
            progress: this.progress,
            lastAccessed: new Date().toISOString()
        };

        localStorage.setItem('scorm_progress', JSON.stringify(progressData));
        this.api.setValue('cmi.core.lesson_status', 'incomplete');
        this.api.setValue('cmi.core.score.raw', this.progress);
        this.api.commit();
    }

    // Chargement de la progression
    loadProgress() {
        const saved = localStorage.getItem('scorm_progress');
        if (saved) {
            const progressData = JSON.parse(saved);
            this.completedSCOs = progressData.completedSCOs || [];
            this.progress = progressData.progress || 0;
        }
    }
}

class SCONavigator {
    constructor(manager) {
        this.manager = manager;
        this.createNavigation();
    }

    createNavigation() {
        const nav = document.createElement('div');
        nav.className = 'sco-navigation';

        this.config.scos.forEach((sco, index) => {
            const button = document.createElement('button');
            button.textContent = sco.title;
            button.disabled = !this.manager.canAccessSCO(sco.id);

            if (this.manager.completedSCOs.includes(sco.id)) {
                button.classList.add('completed');
            }

            button.addEventListener('click', () => {
                this.launchSCO(sco.id);
            });

            nav.appendChild(button);
        });

        document.body.appendChild(nav);
    }

    launchSCO(scoId) {
        const sco = this.config.scos.find(s => s.id === scoId);
        if (sco && this.manager.canAccessSCO(scoId)) {
            // Sauvegarde avant changement
            this.manager.saveProgress();

            // Lancement du SCO
            window.location.href = sco.launch;
        }
    }
}

const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');

class SCORMExporter {
    constructor(packagePath, outputPath) {
        this.packagePath = packagePath;
        this.outputPath = outputPath;
        this.validationResults = [];
    }

    // Validation du manifest
    validateManifest() {
        const manifestPath = path.join(this.packagePath, 'imsmanifest.xml');

        if (!fs.existsSync(manifestPath)) {
            throw new Error('Manifest non trouvé');
        }

        // Validation XML
        const manifest = fs.readFileSync(manifestPath, 'utf8');
        const xmlValidation = this.validateXML(manifest);

        // Validation SCORM
        const scormValidation = this.validateSCORMStructure(manifest);

        return {
            xml: xmlValidation,
            scorm: scormValidation,
            valid: xmlValidation.valid && scormValidation.valid
        };
    }

    // Test de lancement
    testLaunch() {
        const scos = this.extractSCOs();
        const results = [];

        scos.forEach(sco => {
            try {
                // Test de chargement
                const launchTest = this.testSCOLaunch(sco);
                results.push({
                    sco: sco.id,
                    launch: launchTest.success,
                    errors: launchTest.errors
                });
            } catch (error) {
                results.push({
                    sco: sco.id,
                    launch: false,
                    errors: [error.message]
                });
            }
        });

        return results;
    }

    // Génération du rapport STL
    generateSTLReport() {
        const manifestValidation = this.validateManifest();
        const launchTests = this.testLaunch();

        const report = {
            timestamp: new Date().toISOString(),
            package: this.packagePath,
            manifest: manifestValidation,
            launchTests: launchTests,
            overallStatus: this.calculateOverallStatus(manifestValidation, launchTests),
            recommendations: this.generateRecommendations(manifestValidation, launchTests)
        };

        const reportPath = path.join(this.outputPath, 'stl-report.json');
        fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));

        return report;
    }

    // Export du package validé
    exportValidatedPackage() {
        const report = this.generateSTLReport();

        if (report.overallStatus === 'PASS') {
            const exportPath = path.join(this.outputPath, 'validated-package.zip');
            this.createZipPackage(exportPath);
            console.log(`Package validé exporté vers : ${exportPath}`);
        } else {
            console.log('Package non conforme, voir le rapport STL pour les détails');
        }

        return report;
    }
}

// Configuration SCORM dans Canvas
const canvasSCORMConfig = {
    external_tool: {
        name: "SCORM Package",
        url: "https://canvas.example.com/scorm/launch",
        consumer_key: "scorm_consumer_key",
        shared_secret: "scorm_shared_secret",
        privacy_level: "public",
        custom_fields: {
            scorm_package_id: "package_001",
            scorm_version: "1.2",
            max_attempts: 3,
            mastery_score: 80
        }
    }
};

class LMSIntegration {
    constructor(lmsType, config) {
        this.lmsType = lmsType;
        this.config = config;
        this.api = this.initializeAPI();
    }

    initializeAPI() {
        switch(this.lmsType) {
            case 'moodle':
                return new MoodleAPI(this.config);
            case 'canvas':
                return new CanvasAPI(this.config);
            case 'blackboard':
                return new BlackboardAPI(this.config);
            default:
                throw new Error('LMS non supporté');
        }
    }

    // Upload du package SCORM
    async uploadPackage(packagePath) {
        const formData = new FormData();
        formData.append('package', fs.createReadStream(packagePath));
        formData.append('scorm_version', '1.2');
        formData.append('auto_launch', 'true');

        const response = await this.api.uploadSCORM(formData);
        return response.package_id;
    }

    // Configuration du cours
    async configureCourse(packageId, courseConfig) {
        const courseData = {
            package_id: packageId,
            title: courseConfig.title,
            description: courseConfig.description,
            max_attempts: courseConfig.maxAttempts || 3,
            mastery_score: courseConfig.masteryScore || 80,
            due_date: courseConfig.dueDate,
            available_from: courseConfig.availableFrom,
            available_until: courseConfig.availableUntil
        };

        return await this.api.createCourse(courseData);
    }

    // Récupération des rapports
    async getReports(courseId) {
        const reports = await this.api.getSCORMReports(courseId);
        return this.formatReports(reports);
    }

    formatReports(rawReports) {
        return rawReports.map(report => ({
            learner: report.learner_name,
            sco: report.sco_title,
            score: report.score,
            status: report.completion_status,
            timeSpent: report.total_time,
            attempts: report.attempt_count,
            lastAccess: report.last_access_date
        }));
    }
}

// shared/scripts/progress_manager.js
class AdvancedProgressManager {
    constructor() {
        this.scorm = new SCORMAPI();
        this.scoData = {
            currentSCO: this.getCurrentSCO(),
            startTime: new Date(),
            interactions: [],
            objectives: [],
            progress: 0
        };
    }

    // Suivi des interactions
    trackInteraction(id, type, description, response, result) {
        const interaction = {
            id: id,
            type: type,
            description: description,
            response: response,
            result: result,
            timestamp: new Date().toISOString()
        };

        this.scoData.interactions.push(interaction);
        this.saveInteraction(interaction);
    }

    // Gestion des objectifs
    setObjective(objectiveId, score, status) {
        const objective = {
            id: objectiveId,
            score: score,
            status: status,
            timestamp: new Date().toISOString()
        };

        this.scoData.objectives.push(objective);
        this.saveObjective(objective);
    }

    // Calcul de la progression
    calculateProgress() {
        const totalObjectives = this.scoData.objectives.length;
        const completedObjectives = this.scoData.objectives.filter(obj => 
            obj.status === 'completed' || obj.status === 'passed'
        ).length;

        this.scoData.progress = totalObjectives > 0 ? 
            Math.round((completedObjectives / totalObjectives) * 100) : 0;

        return this.scoData.progress;
    }

    // Sauvegarde complète
    saveCompleteProgress() {
        const progress = this.calculateProgress();
        const timeSpent = this.calculateTimeSpent();

        // Sauvegarde SCORM
        this.scorm.setValue('cmi.core.lesson_status', 
            progress === 100 ? 'completed' : 'incomplete');
        this.scorm.setValue('cmi.core.score.raw', progress);
        this.scorm.setValue('cmi.core.total_time', timeSpent);
        this.scorm.setValue('cmi.core.entry', 'resume');

        // Sauvegarde des interactions
        this.scoData.interactions.forEach((interaction, index) => {
            this.scorm.setValue(`cmi.interactions.${index}.id`, interaction.id);
            this.scorm.setValue(`cmi.interactions.${index}.type`, interaction.type);
            this.scorm.setValue(`cmi.interactions.${index}.description`, interaction.description);
            this.scorm.setValue(`cmi.interactions.${index}.learner_response`, interaction.response);
            this.scorm.setValue(`cmi.interactions.${index}.result`, interaction.result);
        });

        this.scorm.commit();
    }

    calculateTimeSpent() {
        const now = new Date();
        const diff = now - this.scoData.startTime;
        const minutes = Math.floor(diff / 60000);
        return `PT${minutes}M`;
    }
}

// Organisation recommandée des fichiers
const scormStructure = {
    'shared/': {
        'scripts/': [
            'scorm_api.js',      // API SCORM de base
            'progress_manager.js', // Gestionnaire de progression
            'navigation.js',     // Navigation entre SCOs
            'utils.js'           // Utilitaires communs
        ],
        'styles/': [
            'main.css',          // Styles principaux
            'scorm.css',         // Styles spécifiques SCORM
            'responsive.css'     // Responsive design
        ],
        'assets/': [
            'images/',           // Images partagées
            'fonts/',            // Polices
            'data/'              // Données statiques
        ]
    },
    'sco1/': {
        'index.html',           // Point d'entrée
        'content.html',         // Contenu principal
        'quiz.html',            // Quiz spécifique
        'scripts/': [
            'sco1-specific.js'  // Scripts spécifiques au SCO
        ]
    }
};

class SCORMErrorHandler {
    static handleAPIError(error, context) {
        console.error(`Erreur SCORM dans ${context}:`, error);

        // Fallback local
        this.saveToLocalStorage(context, error);

        // Notification utilisateur
        this.showUserNotification('Une erreur est survenue. Vos progrès sont sauvegardés localement.');
    }

    static saveToLocalStorage(context, data) {
        const key = `scorm_fallback_${context}`;
        const existing = JSON.parse(localStorage.getItem(key) || '[]');
        existing.push({
            timestamp: new Date().toISOString(),
            data: data
        });
        localStorage.setItem(key, JSON.stringify(existing));
    }
}

// Optimisation des appels API SCORM
class OptimizedSCORMAPI extends SCORMAPI {
    constructor() {
        super();
        this.pendingChanges = new Map();
        this.commitTimeout = null;
    }

    setValue(element, value) {
        // Mise en cache des changements
        this.pendingChanges.set(element, value);

        // Commit différé (évite trop d'appels API)
        this.scheduleCommit();
    }

    scheduleCommit() {
        if (this.commitTimeout) {
            clearTimeout(this.commitTimeout);
        }

        this.commitTimeout = setTimeout(() => {
            this.commitPendingChanges();
        }, 1000); // Commit toutes les secondes
    }

    commitPendingChanges() {
        for (const [element, value] of this.pendingChanges) {
            super.setValue(element, value);
        }
        this.pendingChanges.clear();
        super.commit();
    }
}

// Tests pour les fonctionnalités SCORM
describe('SCORM API Tests', () => {
    let scormAPI;

    beforeEach(() => {
        scormAPI = new SCORMAPI();
    });

    test('should initialize API connection', () => {
        expect(scormAPI.connected).toBe(true);
    });

    test('should save progress correctly', () => {
        scormAPI.setValue('cmi.core.lesson_status', 'completed');
        scormAPI.setValue('cmi.core.score.raw', 85);

        expect(scormAPI.getValue('cmi.core.lesson_status')).toBe('completed');
        expect(scormAPI.getValue('cmi.core.score.raw')).toBe('85');
    });

    test('should handle API errors gracefully', () => {
        // Simulation d'erreur API
        window.parent.API = null;
        const newAPI = new SCORMAPI();

        expect(newAPI.connected).toBe(false);
        expect(newAPI.setValue('test', 'value')).toBe(false);
    });
});

// Tests d'intégration multi-SCO
describe('Multi-SCO Integration Tests', () => {
    test('should navigate between SCOs correctly', async () => {
        const manager = new MultiSCOManager(testConfig);
        const navigator = new SCONavigator(manager);

        // Test de navigation
        await navigator.launchSCO('sco1');
        expect(manager.currentSCO).toBe('sco1');

        await navigator.launchSCO('sco2');
        expect(manager.currentSCO).toBe('sco2');
    });

    test('should respect prerequisites', () => {
        const manager = new MultiSCOManager(testConfig);

        // SCO2 nécessite SCO1
        expect(manager.canAccessSCO('sco2')).toBe(false);

        // Marquer SCO1 comme terminé
        manager.completedSCOs.push('sco1');
        expect(manager.canAccessSCO('sco2')).toBe(true);
    });
});

// Diagnostic de l'API SCORM
function diagnoseSCORMAPI() {
    const diagnosis = {
        apiFound: false,
        apiType: null,
        errors: []
    };

    try {
        if (window.parent && window.parent.API_1484_11) {
            diagnosis.apiFound = true;
            diagnosis.apiType = 'SCORM 2004';
        } else if (window.parent && window.parent.API) {
            diagnosis.apiFound = true;
            diagnosis.apiType = 'SCORM 1.2';
        } else {
            diagnosis.errors.push('Aucune API SCORM détectée');
        }
    } catch (error) {
        diagnosis.errors.push(`Erreur de détection: ${error.message}`);
    }

    return diagnosis;
}

// Diagnostic des problèmes de sauvegarde
function diagnoseSaveIssues() {
    const issues = [];

    // Vérification de la connexion API
    if (!scorm.connected) {
        issues.push('API SCORM non connectée');
    }

    // Vérification des valeurs
    const status = scorm.getValue('cmi.core.lesson_status');
    if (!status) {
        issues.push('Impossible de récupérer le statut');
    }

    // Test de sauvegarde
    const testSave = scorm.setValue('cmi.core.lesson_status', 'incomplete');
    if (!testSave) {
        issues.push('Impossible de sauvegarder les données');
    }

    return issues;
}

// Diagnostic des problèmes de navigation
function diagnoseNavigationIssues() {
    const issues = [];

    // Vérification des SCOs
    const scos = document.querySelectorAll('[data-sco-id]');
    if (scos.length === 0) {
        issues.push('Aucun SCO trouvé dans le DOM');
    }

    // Vérification des prérequis
    const manager = new MultiSCOManager(config);
    config.scos.forEach(sco => {
        if (!manager.canAccessSCO(sco.id)) {
            issues.push(`SCO ${sco.id} non accessible (prérequis manquants)`);
        }
    });

    return issues;
}

// Système de fallback pour la sauvegarde locale
class LocalFallback {
    static saveProgress(data) {
        try {
            localStorage.setItem('scorm_progress', JSON.stringify(data));
            return true;
        } catch (error) {
            console.error('Erreur de sauvegarde locale:', error);
            return false;
        }
    }

    static loadProgress() {
        try {
            const data = localStorage.getItem('scorm_progress');
            return data ? JSON.parse(data) : null;
        } catch (error) {
            console.error('Erreur de chargement local:', error);
            return null;
        }
    }

    static syncWithSCORM(scormAPI) {
        const localData = this.loadProgress();
        if (localData && scormAPI.connected) {
            // Synchronisation des données locales avec SCORM
            Object.keys(localData).forEach(key => {
                scormAPI.setValue(key, localData[key]);
            });
            scormAPI.commit();
        }
    }
}

// Système de monitoring pour le debugging
class SCORMMonitor {
    constructor() {
        this.logs = [];
        this.startMonitoring();
    }

    startMonitoring() {
        // Monitoring des appels API
        const originalSetValue = SCORMAPI.prototype.setValue;
        SCORMAPI.prototype.setValue = function(element, value) {
            this.log('API_SET_VALUE', { element, value });
            return originalSetValue.call(this, element, value);
        };

        // Monitoring des erreurs
        window.addEventListener('error', (event) => {
            this.log('ERROR', {
                message: event.message,
                filename: event.filename,
                lineno: event.lineno,
                colno: event.colno
            });
        });
    }

    log(type, data) {
        this.logs.push({
            timestamp: new Date().toISOString(),
            type: type,
            data: data
        });
    }

    getLogs() {
        return this.logs;
    }

    exportLogs() {
        const logs = this.getLogs();
        const blob = new Blob([JSON.stringify(logs, null, 2)], { type: 'application/json' });
        const url = URL.createObjectURL(blob);
        const a = document.createElement('a');
        a.href = url;
        a.download = 'scorm-logs.json';
        a.click();
    }
}