Rabot

packages/control/optional.py

@@ -154,11 +154,10 @@ def remove(price_data: Dict) -> Dict:
 
         try:
             if self.data.electricity_pricing.configured:
-                if len(self.data.electricity_pricing.get.prices) == 0:
-                    return
-                ep = self.data.electricity_pricing
-                ep.get.prices = remove(ep.get.prices)
-                Pub().pub("openWB/set/optional/ep/get/prices", ep.get.prices)
+                if len(self.data.electricity_pricing.get.prices) >= 0:
+                    ep = self.data.electricity_pricing
+                    ep.get.prices = remove(ep.get.prices)
+                    Pub().pub("openWB/set/optional/ep/get/prices", ep.get.prices)
                 if self._flexible_tariff_module:
                     ep.flexible_tariff.get.prices = remove(ep.flexible_tariff.get.prices)
                     Pub().pub("openWB/set/optional/ep/flexible_tariff/get/prices", ep.flexible_tariff.get.prices)

packages/modules/electricity_pricing/flexible_tariffs/rabot/config.py

@@ -1,24 +1,12 @@
 from typing import Optional
 
 
-class RabotToken():
-    def __init__(self,
-                 access_token: Optional[str] = None,
-                 expires_in: Optional[str] = None,
-                 created_at: Optional[str] = None) -> None:
-        self.access_token = access_token  # don't show in UI
-        self.expires_in = expires_in  # don't show in UI
-        self.created_at = created_at  # don't show in UI
-
-
 class RabotTariffConfiguration:
     def __init__(self,
-                 client_id: Optional[str] = None,
-                 client_secret: Optional[str] = None,
-                 token: RabotToken = None):
-        self.client_id = client_id
-        self.client_secret = client_secret
-        self.token = token or RabotToken()
+                 customer_number: Optional[str] = None,
+                 contract_number: Optional[str] = None):
+        self.customer_number = customer_number
+        self.contract_number = contract_number
 
 
 class RabotTariff:

packages/modules/electricity_pricing/flexible_tariffs/rabot/tariff.py

@@ -2,90 +2,30 @@
 import datetime
 import logging
 from typing import Dict
-from requests.exceptions import HTTPError
 
-from helpermodules.utils.error_handling import ImportErrorContext
-with ImportErrorContext():
-    import pytz
-
-from dataclass_utils import asdict
-from helpermodules import timecheck
-from helpermodules.pub import Pub
 from modules.common import req
 from modules.common.abstract_device import DeviceDescriptor
 from modules.common.component_state import TariffState
-from modules.electricity_pricing.flexible_tariffs.rabot.config import RabotTariff, RabotToken
+from modules.electricity_pricing.flexible_tariffs.rabot.config import RabotTariff
 
 log = logging.getLogger(__name__)
 
 
-def validate_token(config: RabotTariff) -> None:
-    if config.configuration.token.expires_in:
-        expiration = config.configuration.token.created_at + config.configuration.token.expires_in
-        log.debug("No need to authenticate. Valid token already present.")
-        if timecheck.create_timestamp() > expiration:
-            log.debug("Access token expired. Refreshing token.")
-            _refresh_token(config)
-    else:
-        _refresh_token(config)
-
-
-def _refresh_token(config: RabotTariff):
-    data = {
-        'client_id': {config.configuration.client_id},
-        'client_secret': {config.configuration.client_secret},
-        'grant_type': 'client_credentials',
-        'scope': 'openid offline_access api:hems',
-    }
-    response = req.get_http_session().post(
-        'https://auth.rabot-charge.de/connect/token?client_id=&client_secret=&username=&password=&scope=*&'
-        + 'grant_type=client_credentials', data=data).json()
-    config.configuration.token = RabotToken(access_token=response["access_token"],
-                                            expires_in=response["expires_in"],
-                                            created_at=timecheck.create_timestamp())
-    Pub().pub("openWB/set/optional/ep/flexible_tariff/provider", asdict(config))
-
-
 def fetch(config: RabotTariff) -> None:
-    def get_raw_prices():
-        return req.get_http_session().get(
-            "https://api.rabot-charge.de/hems/v1/day-ahead-prices/limited",
-            headers={"Content-Type": "application/json",
-                     "Authorization": f'Bearer {config.configuration.token.access_token}'},
-            params={"from": start_date, "tz": timezone}
-        ).json()["records"]
-
-    validate_token(config)
-    # ToDo: get rid of hard coded timezone!
-    # start_date von voller Stunde sonst liefert die API die nächste Stunde
-    start_date = datetime.datetime.fromtimestamp(
-        timecheck.create_unix_timestamp_current_full_hour()).astimezone(
-            pytz.timezone("Europe/Berlin")).isoformat(sep="T", timespec="seconds")
-    if datetime.datetime.today().astimezone(pytz.timezone("Europe/Berlin")).dst().total_seconds()/3600:
-        # Sommerzeit
-        timezone = "UTC+2:00"
-    else:
-        timezone = "UTC+1:00"
-    try:
-        raw_prices = get_raw_prices()
-    except HTTPError as error:
-        if error.response.status_code == 401:
-            _refresh_token(config)
-            raw_prices = get_raw_prices()
-        else:
-            raise error
+    raw_prices = req.get_http_session().get(
+        f"https://rabot.openwb.de/rabot-proxy.php/customers/{config.configuration.customer_number}"
+        f"/contracts/{config.configuration.contract_number}/metrics",
+        timeout=15
+    ).json()["data"]["records"]
     prices: Dict[int, float] = {}
     for data in raw_prices:
-        formatted_price = data["priceInCentPerKwh"]/100000  # Cent/kWh -> €/Wh
-        timestamp = datetime.datetime.fromisoformat(data["timestamp"]).astimezone(
-            pytz.timezone("Europe/Berlin")).timestamp()
+        formatted_price = data["value"] / 100000  # ct/kWh -> €/Wh
+        timestamp = datetime.datetime.strptime(data["moment"], "%Y-%m-%d %H:%M").timestamp()
         prices.update({str(int(timestamp)): formatted_price})
     return prices
 
 
 def create_electricity_tariff(config: RabotTariff):
-    validate_token(config)
-
     def updater():
         return TariffState(prices=fetch(config))
     return updater

packages/modules/loadvars.py

@@ -155,7 +155,7 @@ def append_thread_set_values(module_name: str) -> None:
                 joined_thread_handler(threads_set_values, None)
                 wait_for_module_update_completed(self.event_module_update_completed,
                                                  "openWB/set/optional/ep/module_update_completed")
-                data.data.copy_module_data()
+                data.data.copy_data()
                 self.price_value_store.update()
         except Exception as e:
             log.exception("Fehler im Optional-Modul: %s", e)