Next release (#1363)

Author: BottlecapDave

_docs/entities/electricity.md

@@ -474,6 +474,28 @@ The total consumption reported by the meter for all time. This will try and upda
 | `is_export` | `boolean` | Determines if the meter exports energy rather than imports |
 | `is_smart_meter` | `boolean` | Determines if the meter is considered smart by Octopus Energy |
 
+### Current Total Export
+
+`sensor.octopus_energy_electricity_{{METER_SERIAL_NUMBER}}_{{MPAN_NUMBER}}_current_total_export`
+
+!!! warning
+    This will only be available if you have specified you have an [Octopus Home Mini](../setup/account.md#home-mini). Do not set unless you have one.
+
+!!! info
+    Not all meters provide this information. In these scenarios, this sensor will report zero or unknown.
+
+!!! note
+    This is [disabled by default](../faq.md#there-are-entities-that-are-disabled-why-are-they-disabled-and-how-do-i-enable-them).
+
+The total export reported by the meter for all time. This will try and update every minute for Home Mini.
+
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `mpan` | `string` | The mpan for the associated meter |
+| `serial_number` | `string` | The serial for the associated meter |
+| `is_export` | `boolean` | Determines if the meter exports energy rather than imports |
+| `is_smart_meter` | `boolean` | Determines if the meter is considered smart by Octopus Energy |
+
 ### Current Accumulative Cost
 
 `sensor.octopus_energy_electricity_{{METER_SERIAL_NUMBER}}_{{MPAN_NUMBER}}_current_accumulative_cost`

_docs/entities/heat_pump.md

@@ -24,15 +24,30 @@ This represents the temperature reported by a sensor (e.g. Cosy Pod) that is ass
 
 `climate.octopus_energy_heat_pump_{{HEAT_PUMP_ID}}_{{ZONE_CODE}}`
 
-This can be used to control the target temperature and mode for a given zone (e.g. water or zone 1) linked to your heat pump. It will also display the current temperature linked to the primary sensor for the zone.
+This can be used to control the target temperature and mode for a given zone (e.g. zone 1) linked to your heat pump. It will also display the current temperature linked to the primary sensor for the zone.
 
 The following operation modes are available
 
 * `Heat` - This represents as `on` in the app
 * `Off` - This represents as `off` in the app
 * `Auto` - This represents as `auto` in the app
 
-In addition, there is the preset of `boost`, which activates boost mode for the zone for 1 hour. If you require boost to be on for a different amount of time, then you can use the [available service](../services.md#octopus_energyboost_heat_pump_zone).
+In addition, there is the preset of `boost`. When `boost` is selected, this activates boost mode for the zone for 1 hour. If a target temperature is not set, then this will default to 50 degrees c. If you require boost to be on for a different amount of time or with a different target temperature, then you can use the [available service](../services.md#octopus_energyboost_heat_pump_zone).
+
+## Water Heater
+
+`water_heater.octopus_energy_heat_pump_{{HEAT_PUMP_ID}}`
+
+This can be used to control the target temperature and mode for a given water heater linked to your heat pump. It will also display the current temperature linked to the primary sensor for the zone.
+
+The following operation modes are available
+
+* `on` - This represents as `on` in the app
+* `off` - This represents as `off` in the app
+* `heat_pump` - This represents as `auto` in the app
+* `high_demand` - This represents as `boost` in the app
+
+When `boost` is selected, this activates boost mode for the zone for 1 hour. If a target temperature is not set, then this will default to 50 degrees c. If you require boost to be on for a different amount of time or with a different target temperature, then you can use the [available service](../services.md#octopus_energyboost_heat_pump_zone).
 
 !!! note
 

_docs/entities/intelligent.md

@@ -39,7 +39,15 @@ This sensor is used to determine if you're currently in a planned dispatch perio
 | `next_start` | `datetime` | The date/time when the next dispatching or off peak rate starts |
 | `next_end` | `datetime` | The date/time when the next dispatching or off peak rate ends |
 
-Each item in `planned_dispatch` or `completed_dispatches` have the following attributes
+Each item in `planned_dispatch` have the following attributes
+
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `start` | `datetime` | The start date/time of the dispatch |
+| `end` | `datetime` | The end date/time of the dispatch |
+| `source` | `string` | Determines what has caused the dispatch to be generated. Will be `SMART`, `BOOST`, `TEST` or None. |
+
+Each item in `completed_dispatches` have the following attributes
 
 | Attribute | Type | Description |
 |-----------|------|-------------|

_docs/services.md

@@ -178,10 +178,6 @@ For automation examples, please refer to the available [blueprints](./blueprints
 
 This service allows the user to perform a spin on the [wheel of fortune](./entities/wheel_of_fortune.md) that is awarded to users every month. No point letting them go to waste :)
 
-!!! warning
-
-    Due to an ongoing issue with the underlying API, this will not award octopoints if used. If you are on Octoplus, it is advised not to use this service.
-
 | Attribute                | Optional | Description                                                                                                           |
 | ------------------------ | -------- | --------------------------------------------------------------------------------------------------------------------- |
 | `target.entity_id`       | `no`     | The name of the wheel of fortune sensor that represents the type of spin to be made. This should always point at one of the [wheel of fortune sensors](./entities/wheel_of_fortune.md) entities. |

custom_components/octopus_energy/__init__.py

@@ -51,10 +51,13 @@
   CONFIG_KIND_TARGET_RATE,
   CONFIG_MAIN_HOME_PRO_ADDRESS,
   CONFIG_MAIN_HOME_PRO_API_KEY,
+  CONFIG_MAIN_HOME_PRO_SETTINGS,
   CONFIG_MAIN_INTELLIGENT_MANUAL_DISPATCHES,
   CONFIG_MAIN_INTELLIGENT_RATE_MODE,
   CONFIG_MAIN_INTELLIGENT_RATE_MODE_PENDING_AND_STARTED_DISPATCHES,
+  CONFIG_MAIN_INTELLIGENT_SETTINGS,
   CONFIG_MAIN_OLD_API_KEY,
+  CONFIG_MAIN_PRICE_CAP_SETTINGS,
   CONFIG_VERSION,
   DATA_DISCOVERY_MANAGER,
   DATA_HEAT_PUMP_CONFIGURATION_AND_STATUS_KEY,
@@ -82,7 +85,7 @@
   REPAIR_UNKNOWN_INTELLIGENT_PROVIDER
 )
 
-ACCOUNT_PLATFORMS = ["sensor", "binary_sensor", "number", "switch", "text", "time", "event", "select", "climate"]
+ACCOUNT_PLATFORMS = ["sensor", "binary_sensor", "number", "switch", "text", "time", "event", "select", "climate", "water_heater"]
 TARGET_RATE_PLATFORMS = ["binary_sensor"]
 COST_TRACKER_PLATFORMS = ["sensor"]
 TARIFF_COMPARISON_PLATFORMS = ["sensor"]
@@ -285,12 +288,12 @@ async def async_setup_dependencies(hass, config):
   account_id = config[CONFIG_ACCOUNT_ID]
 
   electricity_price_cap = None
-  if CONFIG_MAIN_ELECTRICITY_PRICE_CAP in config:
-    electricity_price_cap = config[CONFIG_MAIN_ELECTRICITY_PRICE_CAP]
+  if (CONFIG_MAIN_PRICE_CAP_SETTINGS in config and CONFIG_MAIN_ELECTRICITY_PRICE_CAP in config[CONFIG_MAIN_PRICE_CAP_SETTINGS]):
+    electricity_price_cap = config[CONFIG_MAIN_PRICE_CAP_SETTINGS][CONFIG_MAIN_ELECTRICITY_PRICE_CAP]
 
   gas_price_cap = None
-  if CONFIG_MAIN_GAS_PRICE_CAP in config:
-    gas_price_cap = config[CONFIG_MAIN_GAS_PRICE_CAP]
+  if (CONFIG_MAIN_PRICE_CAP_SETTINGS in config and CONFIG_MAIN_GAS_PRICE_CAP in config[CONFIG_MAIN_PRICE_CAP_SETTINGS]):
+    gas_price_cap = config[CONFIG_MAIN_PRICE_CAP_SETTINGS][CONFIG_MAIN_GAS_PRICE_CAP]
 
   favour_direct_debit_rates = True
   if CONFIG_MAIN_FAVOUR_DIRECT_DEBIT_RATES in config:
@@ -304,9 +307,10 @@ async def async_setup_dependencies(hass, config):
   client = OctopusEnergyApiClient(config[CONFIG_MAIN_API_KEY], electricity_price_cap, gas_price_cap, favour_direct_debit_rates=favour_direct_debit_rates)
   hass.data[DOMAIN][account_id][DATA_CLIENT] = client
 
-  if (CONFIG_MAIN_HOME_PRO_ADDRESS in config and
-      config[CONFIG_MAIN_HOME_PRO_ADDRESS] is not None):
-    home_pro_client = OctopusEnergyHomeProApiClient(config[CONFIG_MAIN_HOME_PRO_ADDRESS], config[CONFIG_MAIN_HOME_PRO_API_KEY] if CONFIG_MAIN_HOME_PRO_API_KEY in config else None)
+  if (CONFIG_MAIN_HOME_PRO_SETTINGS in config and
+      CONFIG_MAIN_HOME_PRO_ADDRESS in config[CONFIG_MAIN_HOME_PRO_SETTINGS] and
+      config[CONFIG_MAIN_HOME_PRO_SETTINGS][CONFIG_MAIN_HOME_PRO_ADDRESS] is not None):
+    home_pro_client = OctopusEnergyHomeProApiClient(config[CONFIG_MAIN_HOME_PRO_SETTINGS][CONFIG_MAIN_HOME_PRO_ADDRESS], config[CONFIG_MAIN_HOME_PRO_SETTINGS][CONFIG_MAIN_HOME_PRO_API_KEY] if CONFIG_MAIN_HOME_PRO_API_KEY in config[CONFIG_MAIN_HOME_PRO_SETTINGS] else None)
     hass.data[DOMAIN][account_id][DATA_HOME_PRO_CLIENT] = home_pro_client
 
   # Delete any issues that may have been previously raised
@@ -440,7 +444,9 @@ async def async_setup_dependencies(hass, config):
           now - timedelta(hours=1)
         )
 
-      if CONFIG_MAIN_INTELLIGENT_MANUAL_DISPATCHES not in config or config[CONFIG_MAIN_INTELLIGENT_MANUAL_DISPATCHES] == False:
+      if (CONFIG_MAIN_INTELLIGENT_SETTINGS not in config or
+          CONFIG_MAIN_INTELLIGENT_MANUAL_DISPATCHES not in config[CONFIG_MAIN_INTELLIGENT_SETTINGS] or
+          config[CONFIG_MAIN_INTELLIGENT_SETTINGS][CONFIG_MAIN_INTELLIGENT_MANUAL_DISPATCHES] == False):
         intelligent_manual_service_enabled = False
 
       await async_save_cached_intelligent_device(hass, account_id, intelligent_device)
@@ -496,13 +502,16 @@ async def async_setup_dependencies(hass, config):
         is_smart_meter = meter["is_smart_meter"]
         override = await async_get_meter_debug_override(hass, mpan, serial_number)
         tariff_override = override.tariff if override is not None else None
+        intelligent_rate_mode = (config[CONFIG_MAIN_INTELLIGENT_SETTINGS][CONFIG_MAIN_INTELLIGENT_RATE_MODE] 
+                                 if CONFIG_MAIN_INTELLIGENT_SETTINGS in config and CONFIG_MAIN_INTELLIGENT_RATE_MODE in config[CONFIG_MAIN_INTELLIGENT_SETTINGS] 
+                                 else CONFIG_MAIN_INTELLIGENT_RATE_MODE_PENDING_AND_STARTED_DISPATCHES)
         await async_setup_electricity_rates_coordinator(hass,
                                                         account_id,
                                                         mpan,
                                                         serial_number,
                                                         is_smart_meter,
                                                         is_export_meter,
-                                                        config[CONFIG_MAIN_INTELLIGENT_RATE_MODE] if CONFIG_MAIN_INTELLIGENT_RATE_MODE in config else CONFIG_MAIN_INTELLIGENT_RATE_MODE_PENDING_AND_STARTED_DISPATCHES,
+                                                        intelligent_rate_mode,
                                                         tariff_override)
 
   mock_heat_pump = account_debug_override.mock_heat_pump if account_debug_override is not None else False
@@ -533,7 +542,7 @@ async def async_setup_dependencies(hass, config):
     hass,
     account_id,
     account_debug_override.mock_intelligent_controls if account_debug_override is not None else False,
-    config[CONFIG_MAIN_INTELLIGENT_MANUAL_DISPATCHES] == True if CONFIG_MAIN_INTELLIGENT_MANUAL_DISPATCHES in config else False,
+    intelligent_manual_service_enabled,
     intelligent_features.planned_dispatches_supported if intelligent_features is not None else True
   )
 

custom_components/octopus_energy/api_client/__init__.py

@@ -113,6 +113,7 @@
     consumption
 		consumptionDelta
     demand
+    export
 	}}
 }}'''
 
@@ -123,15 +124,11 @@
       currentState
     }}
   }}
-	plannedDispatches(accountNumber: "{account_id}") {{
-		start
-		end
-    delta
-    meta {{
-			source
-      location
-		}}
-	}}
+  flexPlannedDispatches(deviceId:"{device_id}") {{
+    start
+    end
+    type
+  }}
 	completedDispatches(accountNumber: "{account_id}") {{
 		start
 		end
@@ -305,20 +302,18 @@
 }}'''
 
 wheel_of_fortune_query = '''query {{
-  wheelOfFortuneSpins(accountNumber: "{account_id}") {{
-    electricity {{
-      remainingSpinsThisMonth
-    }}
-    gas {{
-      remainingSpinsThisMonth
-    }}
+  electricity: wheelOfFortuneSpinsAllowed(fuelType:ELECTRICITY, accountNumber: "{account_id}") {{
+    spinsAllowed
+  }}
+  gas: wheelOfFortuneSpinsAllowed(fuelType:GAS, accountNumber: "{account_id}") {{
+    spinsAllowed
   }}
 }}'''
 
 wheel_of_fortune_mutation = '''mutation {{
-  spinWheelOfFortune(input: {{ accountNumber: "{account_id}", supplyType: {supply_type}, termsAccepted: true }}) {{
-    spinResult {{
-      prizeAmount
+  spinWheelOfFortune(input: {{ accountNumber: "{account_id}", fuelType: {fuel_type} }}) {{
+    prize {{
+      value
     }}
   }}
 }}'''
@@ -647,6 +642,7 @@ def __init__(self, api_key, electricity_price_cap = None, gas_price_cap = None,
 
     self._api_key = api_key
     self._base_url = 'https://api.octopus.energy'
+    self._backend_base_url = 'https://api.backend.octopus.energy'
 
     self._graphql_token = None
     self._graphql_expiration = None
@@ -1138,6 +1134,7 @@ async def async_get_smart_meter_consumption(self, device_id: str, period_from: d
         if (response_body is not None and "data" in response_body and "smartMeterTelemetry" in response_body["data"] and response_body["data"]["smartMeterTelemetry"] is not None and len(response_body["data"]["smartMeterTelemetry"]) > 0):
           return list(map(lambda mp: {
             "total_consumption": float(mp["consumption"]) / 1000 if "consumption" in mp and mp["consumption"] is not None else None,
+            "total_export": float(mp["export"]) / 1000 if "export" in mp and mp["export"] is not None else None,
             "consumption": float(mp["consumptionDelta"]) / 1000 if "consumptionDelta" in mp and mp["consumptionDelta"] is not None else 0,
             "demand": float(mp["demand"]) if "demand" in mp and mp["demand"] is not None else None,
             "start": parse_datetime(mp["readAt"]),
@@ -1434,11 +1431,11 @@ async def async_get_intelligent_dispatches(self, account_id: str, device_id: str
           planned_dispatches = list(map(lambda ev: IntelligentDispatchItem(
               as_utc(parse_datetime(ev["start"])),
               as_utc(parse_datetime(ev["end"])),
-              float(ev["delta"]) if "delta" in ev and ev["delta"] is not None else None,
-              ev["meta"]["source"] if "meta" in ev and "source" in ev["meta"] else None,
-              ev["meta"]["location"] if "meta" in ev and "location" in ev["meta"] else None,
-            ), response_body["data"]["plannedDispatches"]
-            if "plannedDispatches" in response_body["data"] and response_body["data"]["plannedDispatches"] is not None
+              None,
+              ev["type"] if "type" in ev else None,
+              None
+            ), response_body["data"]["flexPlannedDispatches"]
+            if "flexPlannedDispatches" in response_body["data"] and response_body["data"]["flexPlannedDispatches"] is not None
             else [])
           )
 
@@ -1756,20 +1753,21 @@ async def async_get_wheel_of_fortune_spins(self, account_id: str) -> WheelOfFort
     try:
       request_context = "wheel-of-fortune"
       client = self._create_client_session()
-      url = f'{self._base_url}/v1/graphql/'
+      url = f'{self._backend_base_url}/v1/graphql/'
       payload = { "query": wheel_of_fortune_query.format(account_id=account_id) }
-      headers = { "Authorization": f"JWT {self._graphql_token}", integration_context_header: request_context }
+      headers = { "Authorization": f"{self._graphql_token}", integration_context_header: request_context }
       async with client.post(url, json=payload, headers=headers) as response:
         response_body = await self.__async_read_response__(response, url)
         _LOGGER.debug(f'async_get_wheel_of_fortune_spins: {response_body}')
 
         if (response_body is not None and "data" in response_body and
-            "wheelOfFortuneSpins" in response_body["data"]):
+            "electricity" in response_body["data"] and
+            "gas" in response_body["data"]):
 
-          spins = response_body["data"]["wheelOfFortuneSpins"]
+          spins = response_body["data"]
           return WheelOfFortuneSpinsResponse(
-            int(spins["electricity"]["remainingSpinsThisMonth"]) if "electricity" in spins and "remainingSpinsThisMonth" in spins["electricity"] else 0,
-            int(spins["gas"]["remainingSpinsThisMonth"]) if "gas" in spins and "remainingSpinsThisMonth" in spins["gas"] else 0
+            int(spins["electricity"]["spinsAllowed"]) if "electricity" in spins and "spinsAllowed" in spins["electricity"] else 0,
+            int(spins["gas"]["spinsAllowed"]) if "gas" in spins and "spinsAllowed" in spins["gas"] else 0
           )
         else:
           _LOGGER.error("Failed to retrieve wheel of fortune spins")
@@ -1787,20 +1785,20 @@ async def async_spin_wheel_of_fortune(self, account_id: str, is_electricity: boo
     try:
       request_context = "spin-wheel-of-fortune"
       client = self._create_client_session()
-      url = f'{self._base_url}/v1/graphql/'
-      payload = { "query": wheel_of_fortune_mutation.format(account_id=account_id, supply_type="ELECTRICITY" if is_electricity == True else "GAS") }
-      headers = { "Authorization": f"JWT {self._graphql_token}", integration_context_header: request_context }
+      url = f'{self._backend_base_url}/v1/graphql/'
+      payload = { "query": wheel_of_fortune_mutation.format(account_id=account_id, fuel_type="ELECTRICITY" if is_electricity == True else "GAS") }
+      headers = { "Authorization": f"{self._graphql_token}", integration_context_header: request_context }
       async with client.post(url, json=payload, headers=headers) as response:
         response_body = await self.__async_read_response__(response, url)
         _LOGGER.debug(f'async_spin_wheel_of_fortune: {response_body}')
 
         if (response_body is not None and 
             "data" in response_body and
             "spinWheelOfFortune" in response_body["data"] and
-            "spinResult" in response_body["data"]["spinWheelOfFortune"] and
-            "prizeAmount" in response_body["data"]["spinWheelOfFortune"]["spinResult"]):
+            "prize" in response_body["data"]["spinWheelOfFortune"] and
+            "value" in response_body["data"]["spinWheelOfFortune"]["prize"]):
 
-          return int(response_body["data"]["spinWheelOfFortune"]["spinResult"]["prizeAmount"])
+          return int(response_body["data"]["spinWheelOfFortune"]["prize"]["value"])
         else:
           _LOGGER.error("Failed to spin wheel of fortune")