Mejoras en el Launcher C# y gestión de proyectos

- Se añadió la funcionalidad de limpieza del estado previo en el gestor de lanzadores C#. - Se implementó un método para reiniciar completamente el launcher, asegurando una inicialización adecuada. - Se mejoró la gestión de argumentos para ejecutables, permitiendo la selección y ejecución con argumentos predefinidos. - Se optimizó la lógica de inicialización y se añadieron mensajes de depuración para facilitar el seguimiento de errores. - Se realizaron ajustes en la interfaz para mejorar la experiencia del usuario al gestionar proyectos y ejecutables.
2025-06-18 02:44:36 +02:00 · 2025-06-18 02:44:36 +02:00 · e3eb2fb9e5
parent 5be80138c5
commit e3eb2fb9e5
4 changed files with 327 additions and 25 deletions
--- a/data/log.txt
+++ b/data/log.txt
@ -32,3 +32,19 @@
 [01:54:56] ✅ Proceso completado exitosamente (PID: 44892)
 [01:54:56] ⏱️ Tiempo de ejecución: 3.87 segundos
 [01:54:56] ==================================================
+[02:43:57] 🚀 Ejecutando: GTPCorrgir
+[02:43:57] 📁 Directorio: D:/Proyectos/VisualStudio/GTPCorrgir\bin\Release\net8.0-windows
+[02:43:57] ⚡ Comando: D:/Proyectos/VisualStudio/GTPCorrgir\bin\Release\net8.0-windows\GTPCorrgir.exe --Menu
+[02:43:57] ==================================================
+[02:43:57] ✅ Proceso iniciado con PID: 42668
+[02:43:59] ✅ Proceso completado exitosamente (PID: 42668)
+[02:43:59] ⏱️ Tiempo de ejecución: 2.71 segundos
+[02:43:59] ==================================================
+[02:44:06] 🚀 Ejecutando: GTPCorrgir
+[02:44:06] 📁 Directorio: D:/Proyectos/VisualStudio/GTPCorrgir\bin\Release\net8.0-windows
+[02:44:06] ⚡ Comando: D:/Proyectos/VisualStudio/GTPCorrgir\bin\Release\net8.0-windows\GTPCorrgir.exe --Menu
+[02:44:06] ==================================================
+[02:44:06] ✅ Proceso iniciado con PID: 34300
+[02:44:08] ❌ Proceso terminó con código: 1 (PID: 34300)
+[02:44:08] ⏱️ Tiempo de ejecución: 2.09 segundos
+[02:44:08] ==================================================
--- a/static/js/csharp_launcher.js
+++ b/static/js/csharp_launcher.js
@ -12,10 +12,16 @@ class CSharpLauncherManager {
            'Desarrollo', 'APIs', 'Otros'
        ];
        this.currentCategory = 'all';
+        this.initialized = false;
+        this.processInterval = null;
    }

    async init() {
        console.log('Initializing C# Launcher Manager...');
+
+        // Limpiar estado previo si existe
+        this.clearState();
+
        await this.loadProjects();
        await this.loadFavorites();
        this.setupEventListeners();
@ -23,7 +29,35 @@ class CSharpLauncherManager {
        await this.refreshProcesses();

        // Actualizar procesos cada 10 segundos
-        setInterval(() => this.refreshProcesses(), 10000);
+        if (!this.processInterval) {
+            this.processInterval = setInterval(() => this.refreshProcesses(), 10000);
+        }
+
+        this.initialized = true;
+        console.log('C# Launcher Manager initialized successfully');
+    }
+
+    clearState() {
+        console.log('Clearing C# launcher state...');
+        this.currentProject = null;
+        this.projects = [];
+        this.executables = [];
+        this.favorites = new Set();
+        this.runningProcesses = [];
+
+        // Limpiar intervalos previos
+        if (this.processInterval) {
+            clearInterval(this.processInterval);
+            this.processInterval = null;
+        }
+    }
+
+    // Método de utilidad para resetear completamente el launcher
+    async reset() {
+        console.log('Resetting C# Launcher...');
+        localStorage.removeItem('csharp_last_selected_project');
+        this.clearState();
+        await this.init();
    }

    async loadProjects() {
@ -71,7 +105,10 @@ class CSharpLauncherManager {

    renderProjectSelector() {
        const select = document.getElementById('csharp-project-select');
-        if (!select) return;
+        if (!select) {
+            console.warn('C# project select element not found');
+            return;
+        }

        select.innerHTML = '<option value="">-- Seleccionar Proyecto --</option>';

@ -83,24 +120,78 @@ class CSharpLauncherManager {
            option.setAttribute('data-category', project.category || 'Otros');
            select.appendChild(option);
        });
+
+        // Restaurar última selección con delay para asegurar que el DOM esté listo
+        setTimeout(() => this.restoreLastSelectedProject(), 100);
+    }
+
+    restoreLastSelectedProject() {
+        try {
+            const lastSelectedProject = localStorage.getItem('csharp_last_selected_project');
+            console.log('Restoring last selected project:', lastSelectedProject);
+
+            if (!lastSelectedProject) {
+                console.log('No last selected project found');
+                return;
+            }
+
+            const project = this.projects.find(p => p.id === lastSelectedProject);
+            if (!project) {
+                console.log('Last selected project not found in current projects list, clearing localStorage');
+                localStorage.removeItem('csharp_last_selected_project');
+                return;
+            }
+
+            const select = document.getElementById('csharp-project-select');
+            if (!select) {
+                console.warn('Project select element not found during restore');
+                return;
+            }
+
+            console.log('Restoring project:', project.name);
+            select.value = lastSelectedProject;
+
+            // Disparar evento change para cargar el proyecto
+            const changeEvent = new Event('change', { bubbles: true });
+            select.dispatchEvent(changeEvent);
+        } catch (error) {
+            console.error('Error restoring last selected project:', error);
+            // Limpiar localStorage corrupto
+            localStorage.removeItem('csharp_last_selected_project');
+        }
    }

    async onProjectChange(e) {
        const projectId = e.target.value;
+        console.log('Project change event:', projectId);

        if (!projectId) {
+            console.log('No project selected, clearing state');
            this.currentProject = null;
            this.hideCSharpProjectButtons();
            this.clearExecutables();
+            // Limpiar persistencia
+            localStorage.removeItem('csharp_last_selected_project');
            return;
        }

        try {
            this.currentProject = this.projects.find(p => p.id === projectId);
+            if (!this.currentProject) {
+                console.error('Project not found:', projectId);
+                return;
+            }
+
+            console.log('Loading project:', this.currentProject.name);
            this.showCSharpProjectButtons();
            await this.loadProjectExecutables(projectId);
+
+            // Guardar selección para persistencia
+            localStorage.setItem('csharp_last_selected_project', projectId);
+            console.log('Project loaded successfully');
        } catch (error) {
            console.error('Error changing project:', error);
+            this.showNotification('Error cargando el proyecto', 'error');
        }
    }

@ -162,6 +253,11 @@ class CSharpLauncherManager {
        }

        grid.innerHTML = filteredExecutables.map(exe => this.createExecutableCard(exe)).join('');
+
+        // Cargar argumentos para cada ejecutable después de renderizar
+        filteredExecutables.forEach(exe => {
+            this.loadExecutableArgumentsForCard(this.currentProject.id, exe.filename);
+        });
    }

    createExecutableCard(exe) {
@ -171,6 +267,8 @@ class CSharpLauncherManager {
            '<span class="text-xs bg-green-100 text-green-800 px-2 py-1 rounded">Release</span>' :
            '<span class="text-xs bg-yellow-100 text-yellow-800 px-2 py-1 rounded">Debug</span>';

+        // Los argumentos se cargan después de renderizar
+
        return `
            <div class="executable-card bg-white border rounded-lg p-4 hover:shadow-md transition-shadow">
                <div class="flex justify-between items-start mb-2">
@ -183,15 +281,25 @@ class CSharpLauncherManager {
                    ${buildTypeBadge}
                    <span class="text-xs text-gray-500">${exe.filename}</span>
                </div>
+                
+                <!-- Combo de argumentos -->
+                <div class="mb-3">
+                    <select id="args-combo-${exe.filename.replace('.exe', '').replace(/[^a-zA-Z0-9]/g, '_')}" 
+                            class="w-full text-xs border border-gray-300 rounded px-2 py-1 bg-white">
+                        <option value="">Sin argumentos</option>
+                        <!-- Las opciones se cargan dinámicamente -->
+                    </select>
+                </div>
+                
                <div class="flex justify-between items-center">
                    <div class="space-x-1">
                        <button class="text-blue-500 hover:underline text-xs" 
                                onclick="showCSharpExecutableArgs('${this.currentProject.id}', '${exe.filename}', '${exe.display_name}')">
-                            Con Argumentos
+                            Personalizar
                        </button>
                    </div>
                    <button class="bg-blue-500 text-white px-3 py-1 rounded text-xs hover:bg-blue-600"
-                            onclick="csharpLauncherManager.executeExecutable('${this.currentProject.id}', '${exe.filename}')">
+                            onclick="csharpLauncherManager.executeWithSelectedArgs('${this.currentProject.id}', '${exe.filename}')">
                        Ejecutar
                    </button>
                </div>
@ -379,6 +487,50 @@ class CSharpLauncherManager {
        }
    }

+    async loadExecutableArgumentsForCard(projectId, exeName) {
+        try {
+            const response = await fetch(`/api/csharp-executable-arguments/${projectId}/${exeName}`);
+            if (response.ok) {
+                const data = await response.json();
+                const argsList = data.arguments || [];
+                this.populateArgumentsCombo(exeName, argsList);
+            }
+        } catch (error) {
+            console.error('Error loading arguments for card:', error);
+        }
+    }
+
+    populateArgumentsCombo(exeName, argsList) {
+        const comboId = `args-combo-${exeName.replace('.exe', '').replace(/[^a-zA-Z0-9]/g, '_')}`;
+        const combo = document.getElementById(comboId);
+        if (!combo) return;
+
+        // Limpiar opciones existentes excepto "Sin argumentos"
+        combo.innerHTML = '<option value="">Sin argumentos</option>';
+
+        // Agregar argumentos predefinidos
+        argsList.forEach((arg, index) => {
+            const option = document.createElement('option');
+            option.value = arg.arguments;
+            option.textContent = arg.description;
+            option.title = arg.arguments; // Tooltip con los argumentos
+            combo.appendChild(option);
+        });
+    }
+
+    async executeWithSelectedArgs(projectId, exeName) {
+        const comboId = `args-combo-${exeName.replace('.exe', '').replace(/[^a-zA-Z0-9]/g, '_')}`;
+        const combo = document.getElementById(comboId);
+        const selectedArgs = combo ? combo.value : '';
+
+        if (selectedArgs) {
+            const argsArray = selectedArgs.split(' ').filter(arg => arg.length > 0);
+            await this.executeExecutable(projectId, exeName, argsArray);
+        } else {
+            await this.executeExecutable(projectId, exeName);
+        }
+    }
+
    clearExecutables() {
        const grid = document.getElementById('csharp-executables-grid');
        if (grid) {
@ -993,15 +1145,15 @@ async function saveCSharpExecutableMetadata(projectId, exeName) {
        const result = await response.json();

        if (result.status === 'success') {
-            showNotification(result.message, 'success');
+            csharpLauncherManager.showNotification(result.message, 'success');
            closeCSharpMetadataEditor();
            await loadCSharpExecutableManager();
            await csharpLauncherManager.loadProjectExecutables(projectId);
        } else {
-            showNotification(result.message, 'error');
+            csharpLauncherManager.showNotification(result.message, 'error');
        }
    } catch (error) {
-        showNotification('Error guardando metadatos', 'error');
+        csharpLauncherManager.showNotification('Error guardando metadatos', 'error');
        console.error('Error saving metadata:', error);
    }
 }
@ -1022,7 +1174,7 @@ async function editCSharpExecutableArguments(projectId, exeName) {
    }
 }

-function showCSharpArgumentsEditor(projectId, exeName, arguments) {
+function showCSharpArgumentsEditor(projectId, exeName, argsList) {
    const modalHtml = `
        <div id="csharp-arguments-modal" class="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50">
            <div class="bg-white rounded-lg p-6 w-full max-w-4xl max-h-[90vh] overflow-y-auto">
@ -1057,14 +1209,14 @@ function showCSharpArgumentsEditor(projectId, exeName, arguments) {
    `;

    document.body.insertAdjacentHTML('beforeend', modalHtml);
-    renderCSharpArguments(arguments);
+    renderCSharpArguments(argsList);
 }

-function renderCSharpArguments(arguments) {
+function renderCSharpArguments(argsList) {
    const container = document.getElementById('csharp-arguments-list');
    if (!container) return;

-    container.innerHTML = arguments.map((arg, index) => `
+    container.innerHTML = argsList.map((arg, index) => `
        <div class="argument-item bg-gray-50 p-4 rounded-lg" data-index="${index}">
            <div class="grid grid-cols-12 gap-3 items-center">
                <div class="col-span-4">
@ -1087,7 +1239,7 @@ function renderCSharpArguments(arguments) {
        </div>
    `).join('');

-    if (arguments.length === 0) {
+    if (argsList.length === 0) {
        container.innerHTML = `
            <div class="text-center text-gray-500 py-8">
                <div class="text-2xl mb-2">⚙️</div>
@ -1115,40 +1267,48 @@ function removeCSharpArgument(index) {

 function collectCSharpArguments() {
    const argumentItems = document.querySelectorAll('.argument-item');
-    const arguments = [];
+    const argsList = [];

    argumentItems.forEach(item => {
        const description = item.querySelector('.arg-description').value.trim();
        const argumentValue = item.querySelector('.arg-value').value.trim();

        if (description && argumentValue) {
-            arguments.push({ description, arguments: argumentValue });
+            argsList.push({ description, arguments: argumentValue });
        }
    });

-    return arguments;
+    return argsList;
 }

 async function saveCSharpExecutableArguments(projectId, exeName) {
-    const arguments = collectCSharpArguments();
+    const argsList = collectCSharpArguments();

    try {
        const response = await fetch(`/api/csharp-executable-arguments/${projectId}/${exeName}`, {
            method: 'PUT',
            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ arguments })
+            body: JSON.stringify({ arguments: argsList })
        });

        const result = await response.json();

        if (result.status === 'success') {
-            showNotification(result.message, 'success');
+            csharpLauncherManager.showNotification(result.message, 'success');
            closeCSharpArgumentsEditor();
+            // Recargar la lista de ejecutables si está abierto el gestor
+            if (document.getElementById('csharp-executable-manager').style.display !== 'none') {
+                await loadCSharpExecutableManager();
+            }
+            // Recargar argumentos en las cards actuales
+            if (csharpLauncherManager.currentProject) {
+                csharpLauncherManager.loadExecutableArgumentsForCard(projectId, exeName);
+            }
        } else {
-            showNotification(result.message, 'error');
+            csharpLauncherManager.showNotification(result.message, 'error');
        }
    } catch (error) {
-        showNotification('Error guardando argumentos', 'error');
+        csharpLauncherManager.showNotification('Error guardando argumentos', 'error');
        console.error('Error saving arguments:', error);
    }
 }
@ -1254,5 +1414,124 @@ function showCSharpExecutableArgs(projectId, exeName, displayName) {
    }
 }

-// Inicialización global
+// Asegurar inicialización cuando el DOM esté listo
+(function () {
+    console.log('C# Launcher script loaded, preparing initialization...');
+
+    function initializeCSharpLauncher() {
+        try {
+            console.log('Initializing CSharpLauncherManager...');
+            if (!window.csharpLauncherManager) {
                window.csharpLauncherManager = new CSharpLauncherManager();
+                console.log('CSharpLauncherManager created successfully');
+            }
+        } catch (error) {
+            console.error('Error creating CSharpLauncherManager:', error);
+        }
+    }
+
+    // Inicializar inmediatamente si el DOM ya está listo
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', initializeCSharpLauncher);
+    } else {
+        initializeCSharpLauncher();
+    }
+})();
+
+// Función global para debug
+window.debugCSharpLauncher = function () {
+    console.log('=== C# Launcher Debug Info ===');
+    console.log('Initialized:', window.csharpLauncherManager.initialized);
+    console.log('Projects:', window.csharpLauncherManager.projects);
+    console.log('Current Project:', window.csharpLauncherManager.currentProject);
+    console.log('Executables:', window.csharpLauncherManager.executables);
+    console.log('Favorites:', Array.from(window.csharpLauncherManager.favorites));
+    console.log('localStorage:', localStorage.getItem('csharp_last_selected_project'));
+
+    // Verificar elementos DOM
+    const select = document.getElementById('csharp-project-select');
+    console.log('Project Select Element:', select);
+    if (select) {
+        console.log('Select Options:', select.options.length);
+        console.log('Select Value:', select.value);
+    }
+    console.log('==============================');
+};
+
+// Función global para resetear
+window.resetCSharpLauncher = function () {
+    console.log('Resetting C# Launcher...');
+    return window.csharpLauncherManager.reset();
+};
+
+// === FUNCIONES DE RESPALDO PARA EVITAR ERRORES DE REFERENCIA ===
+
+// Asegurar que las funciones globales estén definidas antes de que se necesiten
+document.addEventListener('DOMContentLoaded', function () {
+    console.log('DOM loaded, ensuring C# launcher functions are available...');
+
+    // Solo redefinir si no existe para evitar conflictos
+    if (typeof window.openCSharpProjectEditor === 'undefined') {
+        window.openCSharpProjectEditor = function () {
+            if (!window.csharpLauncherManager) {
+                console.error('csharpLauncherManager not initialized');
+                alert('Error: El launcher C# no está inicializado. Refresca la página.');
+                return;
+            }
+            window.csharpLauncherManager.openProjectEditor();
+        };
+    }
+
+    if (typeof window.loadCSharpExecutables === 'undefined') {
+        window.loadCSharpExecutables = function () {
+            if (!window.csharpLauncherManager) {
+                console.error('csharpLauncherManager not initialized');
+                return;
+            }
+            const select = document.getElementById('csharp-project-select');
+            if (select && window.csharpLauncherManager) {
+                window.csharpLauncherManager.onProjectChange({ target: select });
+            }
+        };
+    }
+
+    if (typeof window.filterCSharpByCategory === 'undefined') {
+        window.filterCSharpByCategory = function (category) {
+            if (!window.csharpLauncherManager) {
+                console.error('csharpLauncherManager not initialized');
+                return;
+            }
+            window.csharpLauncherManager.filterByCategory(category);
+        };
+    }
+
+    if (typeof window.refreshCSharpProcesses === 'undefined') {
+        window.refreshCSharpProcesses = function () {
+            if (!window.csharpLauncherManager) {
+                console.error('csharpLauncherManager not initialized');
+                return;
+            }
+            window.csharpLauncherManager.refreshProcesses();
+        };
+    }
+
+    if (typeof window.openCSharpExecutableManager === 'undefined') {
+        window.openCSharpExecutableManager = function () {
+            if (!window.csharpLauncherManager) {
+                console.error('csharpLauncherManager not initialized');
+                alert('Error: El launcher C# no está inicializado. Refresca la página.');
+                return;
+            }
+
+            if (!window.csharpLauncherManager.currentProject) {
+                alert('Por favor selecciona un proyecto primero');
+                return;
+            }
+
+            // Usar la función ya implementada
+            loadCSharpExecutableManager();
+        };
+    }
+
+    console.log('C# launcher backup functions initialized');
+}); 
--- a/static/js/launcher.js
+++ b/static/js/launcher.js
@ -1371,10 +1371,16 @@ function switchTab(tabName) {
    }

    // Inicializar C# launcher si es la primera vez
-    if (tabName === 'csharp' && !window.csharpLauncherManager.currentProject) {
+    if (tabName === 'csharp') {
+        if (!window.csharpLauncherManager) {
+            console.error('csharpLauncherManager not found! Make sure csharp_launcher.js is loaded.');
+            return;
+        }
+        if (!window.csharpLauncherManager.initialized) {
            window.csharpLauncherManager.init();
        }
    }
+}

 // Funciones para modales
 function openGroupEditor() {
--- a/templates/index.html
+++ b/templates/index.html
@ -385,7 +385,8 @@
                <div class="flex justify-between items-center mb-4">
                    <h2 class="text-xl font-bold">Launcher C# - Proyectos Compilados</h2>
                    <button onclick="openCSharpProjectEditor()"
-                        class="bg-green-500 text-white px-4 py-2 rounded hover:bg-green-600">
+                        class="bg-green-500 text-white px-4 py-2 rounded hover:bg-green-600"
+                        onmousedown="if(!window.openCSharpProjectEditor) alert('Launcher C# cargando...')">
                        Gestionar Proyectos
                    </button>
                </div>