Restructure for enabling/disabling

lib/streaming_providers/providers/magenta2/provider.py

@@ -1,6 +1,6 @@
 # streaming_providers/providers/magenta2/provider.py
 # -*- coding: utf-8 -*-
-from typing import Dict, Optional, List, Any, Tuple
+from typing import Dict, Optional, List, Any, Tuple, ClassVar
 import json
 import base64
 import time
@@ -41,6 +41,8 @@ from .constants import (
 
 
 class Magenta2Provider(StreamingProvider):
+    PROVIDER_LABEL: ClassVar[str] = "Magenta TV 2.0"
+    PROVIDER_LOGO: ClassVar[str] = MAGENTA2_LOGO
     """
     Magenta2 streaming provider implementation with enhanced dynamic discovery
     """
@@ -391,7 +393,7 @@ class Magenta2Provider(StreamingProvider):
 
     @property
     def provider_logo(self) -> str:
-        return MAGENTA2_LOGO
+        return self.PROVIDER_LOGO
 
     @property
     def uses_dynamic_manifests(self) -> bool:

lib/streaming_providers/providers/rtlplus/provider.py

@@ -14,6 +14,7 @@ from ...base.models.proxy_models import ProxyConfig
 
 class RTLPlusProvider(StreamingProvider):
     # Provider constants
+    PROVIDER_LABEL: ClassVar[str] = "RTL+"
     PROVIDER_LOGO: ClassVar[str] = RTLPlusDefaults.RTLPLUS_LOGO
 
     def __init__(self, country: str = 'DE', config: Optional[Dict] = None,

resources/web/config.js

@@ -201,11 +201,14 @@ async function loadProviders() {
         if (!response.ok) throw new Error(`HTTP ${response.status}`);
 
         const data = await response.json();
-        providers = data.providers;
+        providers = data.providers; // Enabled providers with full details
 
-        // Initialize enable manager
+        // NEW: Store all_providers metadata for enable/disable functionality
+        window.allProvidersMetadata = data.all_providers || [];
+
+        // Initialize enable manager with all_providers metadata
         if (window.providerEnableManager) {
-            await window.providerEnableManager.init(providers);
+            await window.providerEnableManager.init(data.all_providers || []);
         }
 
         // Load auth status for each provider

resources/web/provider_enable.js

@@ -3,33 +3,29 @@ class ProviderEnableManager {
     constructor() {
         this.enabledStatus = {};
         this.currentFilter = 'all'; // 'all', 'enabled', 'disabled'
+        this.allProviders = [];
+        this.providers = [];
     }
 
-    async init(providers) {
-        this.providers = providers;
-        await this.loadEnabledStatus();
-    }
+    async init(allProvidersMetadata) {
+        // allProvidersMetadata now comes from /api/providers response's "all_providers" field
+        // It contains ALL providers (enabled and disabled) with metadata
+        this.allProviders = allProvidersMetadata || [];
 
-    async loadEnabledStatus() {
-        try {
-            const response = await fetch(`${API_BASE}/api/providers/enabled`);
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}`);
-            }
-            const data = await response.json();
-            this.enabledStatus = data.providers || {};
-            console.log('Loaded enabled status:', this.enabledStatus);
-        } catch (error) {
-            console.error('Error loading enabled status:', error);
-            // Initialize with defaults (all enabled)
-            this.providers.forEach(p => {
-                this.enabledStatus[p.name] = {
-                    enabled: true,
-                    source: 'default',
-                    can_modify: true
-                };
-            });
-        }
+        // Extract just the enabled providers for backward compatibility
+        this.providers = this.allProviders.filter(p => p.enabled && p.instance_ready);
+
+        // Build enabledStatus from metadata (no separate API call needed)
+        this.enabledStatus = {};
+        this.allProviders.forEach(provider => {
+            this.enabledStatus[provider.name] = {
+                enabled: provider.enabled,
+                source: 'config', // Could be enhanced to detect source from metadata
+                can_modify: true  // All providers can be toggled via POST
+            };
+        });
+
+        console.log('Loaded enabled status from metadata:', this.enabledStatus);
     }
 
     isEnabled(providerName) {
@@ -73,6 +69,15 @@ class ProviderEnableManager {
                 can_modify: true
             };
 
+            // Also update in allProviders array
+            const providerIndex = this.allProviders.findIndex(p => p.name === providerName);
+            if (providerIndex !== -1) {
+                this.allProviders[providerIndex].enabled = newState;
+            }
+
+            // Rebuild enabled providers list
+            this.providers = this.allProviders.filter(p => p.enabled && p.instance_ready);
+
             return true;
         } catch (error) {
             console.error('Error toggling provider:', error);
@@ -152,10 +157,16 @@ class ProviderEnableManager {
     }
 
     getFilteredProviders(tabId) {
-        if (!this.providers) return [];
+        if (!this.allProviders) return [];
 
-        return this.providers.filter(provider =>
-            this.shouldShowInTab(provider.name, tabId)
+        // In credentials tab, show all providers (enabled and disabled)
+        if (tabId === 'credentials') {
+            return this.allProviders;
+        }
+
+        // In other tabs (proxy, epg-mapping), only show enabled providers
+        return this.allProviders.filter(provider =>
+            provider.enabled && provider.instance_ready
         );
     }
 }