v2.0.1-preview: ServiceShield stavy v češtině, oprava dashboard panelu a battery prediction

- Přidány české překlady ServiceShield stavů (aktivní, nečinný, monitoruje, atd.)
- Vylepšena kontrola existence frontend panelu před odstraněním
- Oprava senzoru time_to_empty - zobrazuje 'Nabito' při 100% nabití místo 'Nabíjí se'
- Přesunut battery_prediction_morning_soc do kategorie battery_prediction
- Zlepšené error handling pro neexistující dashboard panely
- Eliminace spam logů 'Removing unknown panel' změnou na debug level

Author: Muriel2Horak

custom_components/oig_cloud/__init__.py

@@ -179,28 +179,66 @@ async def _remove_frontend_panel(hass: HomeAssistant, entry: ConfigEntry) -> Non
 
         from homeassistant.components import frontend
 
+        # OPRAVA: Důkladnější kontrola existence panelu
+        panels_exist = False
+        try:
+            # Zkusíme získat přístup k registrovaným panelům
+            if hasattr(hass, "components") and "frontend" in hass.components:
+                frontend_component = hass.components.frontend
+                if hasattr(frontend_component, "async_register_built_in_panel"):
+                    # Panel systém je dostupný
+                    panels_exist = True
+        except Exception:
+            pass
+
+        if not panels_exist:
+            _LOGGER.debug(
+                f"Frontend panel system not available, skipping removal of {panel_id}"
+            )
+            return
+
+        # OPRAVA: Kontrola existence panelu před odstraněním
+        try:
+            # Pokusíme se získat informace o panelu před jeho odstraněním
+            # Tím ověříme, že skutečně existuje
+            panel_exists = False
+
+            if hasattr(hass.data.get("frontend_panels", {}), panel_id):
+                panel_exists = True
+            elif hasattr(hass.data.get("frontend", {}), "panels"):
+                existing_panels = hass.data["frontend"].panels
+                panel_exists = panel_id in existing_panels
+
+            if not panel_exists:
+                _LOGGER.debug(f"Panel {panel_id} doesn't exist, nothing to remove")
+                return
+        except Exception as check_error:
+            _LOGGER.debug(
+                f"Cannot check panel existence, proceeding with removal attempt: {check_error}"
+            )
+
+        # Pokus o odebrání panelu
         if hasattr(frontend, "async_remove_panel") and callable(
             getattr(frontend, "async_remove_panel")
         ):
-            # OPRAVA: Nejdříve zkontrolujeme, jestli panel existuje
-            if hasattr(hass.data.get("frontend", {}), "panels"):
-                existing_panels = hass.data["frontend"].panels
-                if panel_id in existing_panels:
-                    await frontend.async_remove_panel(hass, panel_id)
-                    _LOGGER.info(f"✅ Panel removed: {panel_id}")
-                else:
-                    _LOGGER.debug(f"Panel {panel_id} not found, nothing to remove")
-            else:
-                # Pokud nemůžeme zkontrolovat existenci, zkusíme smazat přímo
+            try:
                 await frontend.async_remove_panel(hass, panel_id)
                 _LOGGER.info(f"✅ Panel removed: {panel_id}")
+            except ValueError as ve:
+                if "unknown panel" in str(ve).lower():
+                    _LOGGER.debug(
+                        f"Panel {panel_id} was already removed or never existed"
+                    )
+                else:
+                    _LOGGER.warning(f"Error removing panel {panel_id}: {ve}")
+            except Exception as re:
+                _LOGGER.debug(f"Panel removal handled (panel may not exist): {re}")
         else:
             _LOGGER.debug("async_remove_panel not available")
 
     except Exception as e:
-        _LOGGER.debug(
-            f"Error removing frontend panel (this is expected if panel doesn't exist): {e}"
-        )
+        # OPRAVA: Všechny chyby logujeme jako debug, protože jsou očekávané
+        _LOGGER.debug(f"Panel removal handled gracefully: {e}")
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
@@ -389,7 +427,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
             _LOGGER.debug("Spot prices disabled - skipping OTE API initialization")
 
         # NOVÉ: Podmíněné nastavení dashboard podle konfigurace
-        dashboard_enabled = entry.options.get("enable_dashboard", False)
+        dashboard_enabled = entry.options.get(
+            "enable_dashboard", False
+        )  # OPRAVA: default False místo True
         # OPRAVA: Dashboard registrujeme AŽ PO vytvoření senzorů
 
         # Uložení dat do hass.data
@@ -437,13 +477,15 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         # Vždy registrovat sensor platform
         await hass.config_entries.async_forward_entry_setups(entry, ["sensor"])
 
-        # OPRAVA: Dashboard registrujeme až TERAZ - po vytvoření všech senzorů
+        # OPRAVA: Dashboard registrujeme až TERAZ - po vytvoření všech senzorů A POUZE pokud je enabled
         if dashboard_enabled:
             await _setup_frontend_panel(hass, entry)
             _LOGGER.info("OIG Cloud Dashboard panel enabled and registered")
         else:
             await _remove_frontend_panel(hass, entry)
-            _LOGGER.debug("OIG Cloud Dashboard panel disabled")
+            _LOGGER.info(
+                "OIG Cloud Dashboard panel disabled - panel not registered"
+            )  # OPRAVA: lepší log message
 
         # Přidáme listener pro změny konfigurace - OPRAVEN callback na async funkci
         entry.async_on_unload(entry.add_update_listener(async_update_options))
@@ -594,6 +636,10 @@ async def async_update_options(
     old_dashboard_enabled = old_options.get("enable_dashboard", False)
     new_dashboard_enabled = new_options.get("enable_dashboard", False)
 
+    _LOGGER.debug(
+        f"Dashboard options update: old={old_dashboard_enabled}, new={new_dashboard_enabled}"
+    )
+
     if old_dashboard_enabled != new_dashboard_enabled:
         _LOGGER.info(
             f"Dashboard setting changed: {old_dashboard_enabled} -> {new_dashboard_enabled}"
@@ -616,6 +662,11 @@ async def async_update_options(
             hass.data[DOMAIN][config_entry.entry_id]["config"][
                 "enable_dashboard"
             ] = new_dashboard_enabled
+    else:
+        # PŘIDÁNO: I když se hodnota nezměnila, ujistíme se že panel není registrován pokud je disabled
+        if not new_dashboard_enabled:
+            await _remove_frontend_panel(hass, config_entry)
+            _LOGGER.debug("Ensuring dashboard panel is not registered (disabled)")
 
     # Pokud byla označena potřeba reload, proveď ho
     if new_options.get("_needs_reload"):

custom_components/oig_cloud/config_flow.py

@@ -150,7 +150,7 @@ async def validate_input(hass, data: Dict[str, Any]) -> Dict[str, Any]:
         ): bool,
         vol.Optional(
             "enable_dashboard",
-            default=True,
+            default=False,  # OPRAVA: změna z True na False
             description="Povolit webový dashboard s grafy",
         ): bool,  # NOVÉ: dashboard option
     }
@@ -222,6 +222,10 @@ async def async_step_user(
                     "enable_extended_fve_sensors": True,
                     "enable_extended_grid_sensors": True,
                     "disable_extended_stats_api": False,
+                    # OPRAVA: Explicitně zakázat battery prediction
+                    "enable_battery_prediction": False,
+                    # OPRAVA: Explicitně zakázat dashboard
+                    "enable_dashboard": user_input.get("enable_dashboard", False),
                 },
             )
 
@@ -436,7 +440,7 @@ async def async_step_extended_sensors(
             step_id="extended_sensors",
             data_schema=vol.Schema(schema_fields),
             description_placeholders={
-                "current_state": "Povoleno" if extended_enabled else "Zakázáno",
+                "current_state": "Povolen" if extended_enabled else "Zakázáno",
                 "info": (
                     "⚠️ Rozšířené senzory jsou vypnuté - sub-moduly se aktivují po zapnutí"
                     if not extended_enabled
@@ -500,8 +504,8 @@ async def async_step_battery_prediction(
                 vol.Required(
                     "info_only",
                     default="back_to_menu",
-                    description="⚠️ MODUL VE VÝVOJI - Změny nejsou možné",
-                ): vol.In({"back_to_menu": "⬅️ Zpět do hlavního menu"})
+                    description="Modul ve vývoji - změny nejsou možné",
+                ): vol.In({"back_to_menu": "Zpět do hlavního menu"})
             }
         )
 
@@ -515,25 +519,7 @@ async def async_step_battery_prediction(
                 "percentile": current_options.get("percentile_conf", 80.0),
                 "max_price": current_options.get("max_price_conf", 4.0),
                 "total_hours": current_options.get("total_hours", 24),
-                "dev_status": "🚧 MODUL VE VÝVOJI",
-                "info": (
-                    "⚠️ POUZE PRO ČTENÍ - MODUL VE VÝVOJI\n\n"
-                    "Predikce baterie je momentálně ve vývoji a není dostupná pro konfiguraci. "
-                    f"Aktuální stav: {('POVOLEN' if battery_enabled else 'ZAKÁZÁN')}"
-                    + (
-                        f"\n\nAktuální parametry:\n"
-                        f"• Min. kapacita: {current_options.get('min_capacity_percent', 20.0)}%\n"
-                        f"• Nabíjecí výkon: {current_options.get('home_charge_rate', 2800)}W\n"
-                        f"• Percentil: {current_options.get('percentile_conf', 80.0)}%\n"
-                        f"• Max. cena: {current_options.get('max_price_conf', 4.0)} CZK/kWh\n"
-                        f"• Horizont: {current_options.get('total_hours', 24)}h"
-                        if battery_enabled
-                        else ""
-                    )
-                ),
-                "requirements": "POŽADAVKY: Statistiky (📊) + Spotové ceny (💰) musí být zapnuté",
-                "features": "PLÁNOVANÉ FUNKCE: • Inteligentní plánování nabíjení • Optimalizace podle spotových cen • Predikce kapacity baterie • Automatické doporučení kdy nabíjet",
-                "timeline": "ČASOVÝ PLÁN: Modul bude dokončen v příští verzi integrace",
+                "info": "Predikce baterie je momentálně ve vývoji a není dostupná pro konfiguraci",
             },
         )
 
@@ -1444,8 +1430,8 @@ async def async_step_dashboard_config(
                 vol.Required(
                     "info_only",
                     default="back_to_menu",
-                    description="⚠️ MODUL VE VÝVOJI - Změny nejsou možné",
-                ): vol.In({"back_to_menu": "⬅️ Zpět do hlavního menu"})
+                    description="Modul ve vývoji - změny nejsou možné",
+                ): vol.In({"back_to_menu": "Zpět do hlavního menu"})
             }
         )
 
@@ -1454,15 +1440,6 @@ async def async_step_dashboard_config(
             data_schema=schema,
             description_placeholders={
                 "current_state": ("Povolen" if dashboard_enabled else "Zakázán"),
-                "dev_status": "🚧 MODUL VE VÝVOJI",
-                "info": (
-                    "⚠️ POUZE PRO ČTENÍ - MODUL VE VÝVOJI\n\n"
-                    "Webový dashboard je momentálně ve vývoji a není dostupný pro konfiguraci. "
-                    f"Aktuální stav: {('POVOLEN' if dashboard_enabled else 'ZAKÁZÁN')}\n\n"
-                    "Dashboard bude automaticky dostupný v levém menu Home Assistant po dokončení vývoje."
-                ),
-                "features": "PLÁNOVANÉ FUNKCE:\n• Predikce kapacity baterie\n• Solární předpověď\n• Spotové ceny elektřiny\n• Interaktivní grafy s Apex Charts\n• Real-time monitoring\n• Exporty dat",
-                "timeline": "ČASOVÝ PLÁN: Dashboard bude dokončen v příští verzi integrace",
-                "access": "PŘÍSTUP: Po dokončení bude dostupný přes levé menu → 'OIG Dashboard'",
+                "info": "Webový dashboard je momentálně ve vývoji a není dostupný pro konfiguraci",
             },
         )

custom_components/oig_cloud/oig_cloud_computed_sensor.py

@@ -195,7 +195,11 @@ def state(self) -> Optional[Union[float, str]]:
                 usable = bat_p * 0.8
                 missing = bat_p * (1 - bat_c / 100)
                 remaining = usable - missing
-                if bat_power < 0:
+
+                # OPRAVA: Kontrola na plně nabitou baterii (100%)
+                if bat_c >= 100:
+                    return "Nabito"
+                elif bat_power < 0:
                     return self._format_time(remaining / abs(bat_power))
                 elif remaining == 0:
                     return "Vybito"

custom_components/oig_cloud/oig_cloud_shield_sensor.py

@@ -9,6 +9,25 @@
 
 _LOGGER = logging.getLogger(__name__)
 
+# OPRAVA: České překlady pro ServiceShield stavy
+SERVICESHIELD_STATE_TRANSLATIONS: Dict[str, str] = {
+    "active": "aktivní",
+    "idle": "nečinný",
+    "monitoring": "monitoruje",
+    "protecting": "chrání",
+    "disabled": "zakázán",
+    "error": "chyba",
+    "starting": "spouští se",
+    "stopping": "zastavuje se",
+    "unknown": "neznámý",
+    "unavailable": "nedostupný",
+}
+
+
+def translate_shield_state(state: str) -> str:
+    """Přeloží ServiceShield stav do češtiny."""
+    return SERVICESHIELD_STATE_TRANSLATIONS.get(state.lower(), state)
+
 
 class OigCloudShieldSensor(OigCloudSensor):
     """Senzor pro ServiceShield monitoring."""
@@ -91,10 +110,10 @@ def state(self) -> Optional[Union[str, int, datetime]]:
         try:
             shield = self.hass.data[DOMAIN].get("shield")
             if not shield:
-                return "unavailable"
+                return translate_shield_state("unavailable")
 
             if self._sensor_type == "service_shield_status":
-                return "active"
+                return translate_shield_state("active")
             elif self._sensor_type == "service_shield_queue":
                 # Celkový počet: čekající ve frontě + všechny pending služby
                 queue = getattr(shield, "queue", [])
@@ -105,13 +124,13 @@ def state(self) -> Optional[Union[str, int, datetime]]:
                 if running:
                     return running.replace("oig_cloud.", "")
                 else:
-                    return "idle"
+                    return translate_shield_state("idle")
 
         except Exception as e:
             _LOGGER.error(f"Error getting shield sensor state: {e}")
-            return None
+            return translate_shield_state("error")
 
-        return None
+        return translate_shield_state("unknown")
 
     @property
     def extra_state_attributes(self) -> Dict[str, Any]:

custom_components/oig_cloud/sensor.py

@@ -417,7 +417,9 @@ async def async_setup_entry(
         _LOGGER.error(f"Error initializing notification sensors: {e}")
 
     # 8. Battery Prediction sensors - pouze pokud je povolen
-    battery_prediction_enabled = entry.options.get("enable_battery_prediction", True)
+    battery_prediction_enabled = entry.options.get(
+        "enable_battery_prediction", False
+    )  # OPRAVA: změna z True na False
     _LOGGER.info(f"Battery prediction enabled: {battery_prediction_enabled}")
 
     if battery_prediction_enabled:

custom_components/oig_cloud/sensors/SENSOR_TYPES_STATISTICS.py

@@ -169,7 +169,7 @@
         "unit": UnitOfTime.HOURS,
         "icon": "mdi:battery-clock",
         "device_class": SensorDeviceClass.DURATION,
-        "sensor_type_category": "statistics",
+        "sensor_type_category": "battery_prediction",
     },
     "battery_prediction_needed_capacity": {
         "name": "Battery Needed Capacity Prediction",
@@ -178,7 +178,7 @@
         "icon": "mdi:battery-plus",
         "device_class": SensorDeviceClass.ENERGY,
         "state_class": SensorStateClass.TOTAL,
-        "sensor_type_category": "statistics",
+        "sensor_type_category": "battery_prediction",
     },
     "battery_prediction_morning_soc": {
         "name": "Battery Morning SOC Prediction",
@@ -187,7 +187,7 @@
         "icon": "mdi:battery-clock-outline",
         "device_class": SensorDeviceClass.BATTERY,
         "state_class": SensorStateClass.MEASUREMENT,
-        "sensor_type_category": "statistics",
+        "sensor_type_category": "battery_prediction",
     },
     # Hodinové reálné senzory - používají existující computed energy senzory
     "hourly_real_battery_charge_kwh": {