git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2024 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.energidataservice.internal.handler;
  14
  15 import static org.openhab.binding.energidataservice.internal.EnergiDataServiceBindingConstants.*;
  16 import static org.openhab.core.types.TimeSeries.Policy.REPLACE;
  17
  18 import java.math.BigDecimal;
  19 import java.time.Duration;
  20 import java.time.Instant;
  21 import java.time.LocalDateTime;
  22 import java.time.LocalTime;
  23 import java.time.format.DateTimeFormatter;
  24 import java.time.temporal.ChronoUnit;
  25 import java.util.Arrays;
  26 import java.util.Collection;
  27 import java.util.Currency;
  28 import java.util.HashMap;
  29 import java.util.List;
  30 import java.util.Map;
  31 import java.util.Map.Entry;
  32 import java.util.Set;
  33 import java.util.concurrent.ScheduledFuture;
  34 import java.util.concurrent.TimeUnit;
  35
  36 import javax.measure.Unit;
  37
  38 import org.eclipse.jdt.annotation.NonNullByDefault;
  39 import org.eclipse.jdt.annotation.Nullable;
  40 import org.eclipse.jetty.client.HttpClient;
  41 import org.eclipse.jetty.http.HttpStatus;
  42 import org.openhab.binding.energidataservice.internal.ApiController;
  43 import org.openhab.binding.energidataservice.internal.CacheManager;
  44 import org.openhab.binding.energidataservice.internal.DatahubTariff;
  45 import org.openhab.binding.energidataservice.internal.action.EnergiDataServiceActions;
  46 import org.openhab.binding.energidataservice.internal.api.ChargeType;
  47 import org.openhab.binding.energidataservice.internal.api.ChargeTypeCode;
  48 import org.openhab.binding.energidataservice.internal.api.DatahubTariffFilter;
  49 import org.openhab.binding.energidataservice.internal.api.DatahubTariffFilterFactory;
  50 import org.openhab.binding.energidataservice.internal.api.Dataset;
  51 import org.openhab.binding.energidataservice.internal.api.DateQueryParameter;
  52 import org.openhab.binding.energidataservice.internal.api.DateQueryParameterType;
  53 import org.openhab.binding.energidataservice.internal.api.GlobalLocationNumber;
  54 import org.openhab.binding.energidataservice.internal.api.dto.CO2EmissionRecord;
  55 import org.openhab.binding.energidataservice.internal.api.dto.DatahubPricelistRecord;
  56 import org.openhab.binding.energidataservice.internal.api.dto.ElspotpriceRecord;
  57 import org.openhab.binding.energidataservice.internal.config.DatahubPriceConfiguration;
  58 import org.openhab.binding.energidataservice.internal.config.EnergiDataServiceConfiguration;
  59 import org.openhab.binding.energidataservice.internal.exception.DataServiceException;
  60 import org.openhab.binding.energidataservice.internal.retry.RetryPolicyFactory;
  61 import org.openhab.binding.energidataservice.internal.retry.RetryStrategy;
  62 import org.openhab.core.i18n.TimeZoneProvider;
  63 import org.openhab.core.library.types.DecimalType;
  64 import org.openhab.core.library.types.QuantityType;
  65 import org.openhab.core.library.unit.CurrencyUnits;
  66 import org.openhab.core.library.unit.Units;
  67 import org.openhab.core.thing.Channel;
  68 import org.openhab.core.thing.ChannelUID;
  69 import org.openhab.core.thing.Thing;
  70 import org.openhab.core.thing.ThingStatus;
  71 import org.openhab.core.thing.ThingStatusDetail;
  72 import org.openhab.core.thing.binding.BaseThingHandler;
  73 import org.openhab.core.thing.binding.ThingHandlerService;
  74 import org.openhab.core.types.Command;
  75 import org.openhab.core.types.RefreshType;
  76 import org.openhab.core.types.State;
  77 import org.openhab.core.types.TimeSeries;
  78 import org.openhab.core.types.UnDefType;
  79 import org.slf4j.Logger;
  80 import org.slf4j.LoggerFactory;
  81
  82 /**
  83  * The {@link EnergiDataServiceHandler} is responsible for handling commands, which are
  84  * sent to one of the channels.
  85  *
  86  * @author Jacob Laursen - Initial contribution
  87  */
  88 @NonNullByDefault
  89 public class EnergiDataServiceHandler extends BaseThingHandler {
  90
  91     private static final Duration emissionPrognosisJobInterval = Duration.ofMinutes(15);
  92     private static final Duration emissionRealtimeJobInterval = Duration.ofMinutes(5);
  93
  94     private final Logger logger = LoggerFactory.getLogger(EnergiDataServiceHandler.class);
  95     private final TimeZoneProvider timeZoneProvider;
  96     private final ApiController apiController;
  97     private final CacheManager cacheManager;
  98
  99     private EnergiDataServiceConfiguration config;
 100     private RetryStrategy retryPolicy = RetryPolicyFactory.initial();
 101     private boolean realtimeEmissionsFetchedFirstTime = false;
 102     private @Nullable ScheduledFuture<?> refreshPriceFuture;
 103     private @Nullable ScheduledFuture<?> refreshEmissionPrognosisFuture;
 104     private @Nullable ScheduledFuture<?> refreshEmissionRealtimeFuture;
 105     private @Nullable ScheduledFuture<?> priceUpdateFuture;
 106
 107     public EnergiDataServiceHandler(Thing thing, HttpClient httpClient, TimeZoneProvider timeZoneProvider) {
 108         super(thing);
 109         this.timeZoneProvider = timeZoneProvider;
 110         this.apiController = new ApiController(httpClient, timeZoneProvider);
 111         this.cacheManager = new CacheManager();
 112
 113         // Default configuration
 114         this.config = new EnergiDataServiceConfiguration();
 115     }
 116
 117     @Override
 118     public void handleCommand(ChannelUID channelUID, Command command) {
 119         if (!(command instanceof RefreshType)) {
 120             return;
 121         }
 122
 123         String channelId = channelUID.getId();
 124         if (ELECTRICITY_CHANNELS.contains(channelId)) {
 125             refreshElectricityPrices();
 126         } else if (CHANNEL_CO2_EMISSION_PROGNOSIS.equals(channelId)) {
 127             rescheduleEmissionPrognosisJob();
 128         } else if (CHANNEL_CO2_EMISSION_REALTIME.equals(channelId)) {
 129             realtimeEmissionsFetchedFirstTime = false;
 130             rescheduleEmissionRealtimeJob();
 131         }
 132     }
 133
 134     @Override
 135     public void initialize() {
 136         config = getConfigAs(EnergiDataServiceConfiguration.class);
 137
 138         if (config.priceArea.isBlank()) {
 139             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.CONFIGURATION_ERROR,
 140                     "@text/offline.conf-error.no-price-area");
 141             return;
 142         }
 143         GlobalLocationNumber gln = config.getGridCompanyGLN();
 144         if (!gln.isEmpty() && !gln.isValid()) {
 145             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.CONFIGURATION_ERROR,
 146                     "@text/offline.conf-error.invalid-grid-company-gln");
 147             return;
 148         }
 149         gln = config.getEnerginetGLN();
 150         if (!gln.isEmpty() && !gln.isValid()) {
 151             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.CONFIGURATION_ERROR,
 152                     "@text/offline.conf-error.invalid-energinet-gln");
 153             return;
 154         }
 155
 156         updateStatus(ThingStatus.UNKNOWN);
 157
 158         refreshPriceFuture = scheduler.schedule(this::refreshElectricityPrices, 0, TimeUnit.SECONDS);
 159
 160         if (isLinked(CHANNEL_CO2_EMISSION_PROGNOSIS)) {
 161             rescheduleEmissionPrognosisJob();
 162         }
 163         if (isLinked(CHANNEL_CO2_EMISSION_REALTIME)) {
 164             rescheduleEmissionRealtimeJob();
 165         }
 166     }
 167
 168     @Override
 169     public void dispose() {
 170         ScheduledFuture<?> refreshPriceFuture = this.refreshPriceFuture;
 171         if (refreshPriceFuture != null) {
 172             refreshPriceFuture.cancel(true);
 173             this.refreshPriceFuture = null;
 174         }
 175         ScheduledFuture<?> refreshEmissionPrognosisFuture = this.refreshEmissionPrognosisFuture;
 176         if (refreshEmissionPrognosisFuture != null) {
 177             refreshEmissionPrognosisFuture.cancel(true);
 178             this.refreshEmissionPrognosisFuture = null;
 179         }
 180         ScheduledFuture<?> refreshEmissionRealtimeFuture = this.refreshEmissionRealtimeFuture;
 181         if (refreshEmissionRealtimeFuture != null) {
 182             refreshEmissionRealtimeFuture.cancel(true);
 183             this.refreshEmissionRealtimeFuture = null;
 184         }
 185         ScheduledFuture<?> priceUpdateFuture = this.priceUpdateFuture;
 186         if (priceUpdateFuture != null) {
 187             priceUpdateFuture.cancel(true);
 188             this.priceUpdateFuture = null;
 189         }
 190
 191         cacheManager.clear();
 192     }
 193
 194     @Override
 195     public Collection<Class<? extends ThingHandlerService>> getServices() {
 196         return Set.of(EnergiDataServiceActions.class);
 197     }
 198
 199     @Override
 200     public void channelLinked(ChannelUID channelUID) {
 201         super.channelLinked(channelUID);
 202
 203         if (!"DK1".equals(config.priceArea) && !"DK2".equals(config.priceArea)
 204                 && (CHANNEL_CO2_EMISSION_PROGNOSIS.equals(channelUID.getId())
 205                         || CHANNEL_CO2_EMISSION_REALTIME.contains(channelUID.getId()))) {
 206             logger.warn("Item linked to channel '{}', but price area {} is not supported for this channel",
 207                     channelUID.getId(), config.priceArea);
 208         }
 209     }
 210
 211     @Override
 212     public void channelUnlinked(ChannelUID channelUID) {
 213         super.channelUnlinked(channelUID);
 214
 215         if (CHANNEL_CO2_EMISSION_PROGNOSIS.equals(channelUID.getId()) && !isLinked(CHANNEL_CO2_EMISSION_PROGNOSIS)) {
 216             logger.debug("No more items linked to channel '{}', stopping emission prognosis refresh job",
 217                     channelUID.getId());
 218             ScheduledFuture<?> refreshEmissionPrognosisFuture = this.refreshEmissionPrognosisFuture;
 219             if (refreshEmissionPrognosisFuture != null) {
 220                 refreshEmissionPrognosisFuture.cancel(true);
 221                 this.refreshEmissionPrognosisFuture = null;
 222             }
 223         } else if (CHANNEL_CO2_EMISSION_REALTIME.contains(channelUID.getId())
 224                 && !isLinked(CHANNEL_CO2_EMISSION_REALTIME)) {
 225             logger.debug("No more items linked to channel '{}', stopping realtime emission refresh job",
 226                     channelUID.getId());
 227             ScheduledFuture<?> refreshEmissionRealtimeFuture = this.refreshEmissionRealtimeFuture;
 228             if (refreshEmissionRealtimeFuture != null) {
 229                 refreshEmissionRealtimeFuture.cancel(true);
 230                 this.refreshEmissionRealtimeFuture = null;
 231             }
 232         }
 233     }
 234
 235     private void refreshElectricityPrices() {
 236         RetryStrategy retryPolicy;
 237         try {
 238             if (isLinked(CHANNEL_SPOT_PRICE)) {
 239                 downloadSpotPrices();
 240             }
 241
 242             for (DatahubTariff datahubTariff : DatahubTariff.values()) {
 243                 if (isLinked(datahubTariff.getChannelId())) {
 244                     downloadTariffs(datahubTariff);
 245                 }
 246             }
 247
 248             updateStatus(ThingStatus.ONLINE);
 249             updatePrices();
 250             updateTimeSeries();
 251
 252             if (isLinked(CHANNEL_SPOT_PRICE)) {
 253                 if (cacheManager.getNumberOfFutureSpotPrices() < 13) {
 254                     logger.warn("Spot prices are not yet available, retry scheduled (see details in Thing properties)");
 255                     retryPolicy = RetryPolicyFactory.whenExpectedSpotPriceDataMissing(DAILY_REFRESH_TIME_CET,
 256                             NORD_POOL_TIMEZONE);
 257                 } else {
 258                     retryPolicy = RetryPolicyFactory.atFixedTime(DAILY_REFRESH_TIME_CET, NORD_POOL_TIMEZONE);
 259                 }
 260             } else {
 261                 retryPolicy = RetryPolicyFactory.atFixedTime(LocalTime.MIDNIGHT, timeZoneProvider.getTimeZone());
 262             }
 263         } catch (DataServiceException e) {
 264             if (e.getHttpStatus() != 0) {
 265                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.COMMUNICATION_ERROR,
 266                         HttpStatus.getCode(e.getHttpStatus()).getMessage());
 267             } else {
 268                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.COMMUNICATION_ERROR, e.getMessage());
 269             }
 270             if (e.getCause() != null) {
 271                 logger.debug("Error retrieving prices", e);
 272             }
 273             retryPolicy = RetryPolicyFactory.fromThrowable(e);
 274         } catch (InterruptedException e) {
 275             logger.debug("Refresh job interrupted");
 276             Thread.currentThread().interrupt();
 277             return;
 278         }
 279
 280         reschedulePriceRefreshJob(retryPolicy);
 281     }
 282
 283     private void downloadSpotPrices() throws InterruptedException, DataServiceException {
 284         if (cacheManager.areSpotPricesFullyCached()) {
 285             logger.debug("Cached spot prices still valid, skipping download.");
 286             return;
 287         }
 288         DateQueryParameter start;
 289         if (cacheManager.areHistoricSpotPricesCached()) {
 290             start = DateQueryParameter.of(DateQueryParameterType.UTC_NOW);
 291         } else {
 292             start = DateQueryParameter.of(DateQueryParameterType.UTC_NOW,
 293                     Duration.ofHours(-CacheManager.NUMBER_OF_HISTORIC_HOURS));
 294         }
 295         Map<String, String> properties = editProperties();
 296         ElspotpriceRecord[] spotPriceRecords = apiController.getSpotPrices(config.priceArea, config.getCurrency(),
 297                 start, properties);
 298         cacheManager.putSpotPrices(spotPriceRecords, config.getCurrency());
 299         updateProperties(properties);
 300     }
 301
 302     private void downloadTariffs(DatahubTariff datahubTariff) throws InterruptedException, DataServiceException {
 303         GlobalLocationNumber globalLocationNumber = switch (datahubTariff) {
 304             case GRID_TARIFF -> config.getGridCompanyGLN();
 305             default -> config.getEnerginetGLN();
 306         };
 307         if (globalLocationNumber.isEmpty()) {
 308             return;
 309         }
 310         if (cacheManager.areTariffsValidTomorrow(datahubTariff)) {
 311             logger.debug("Cached tariffs of type {} still valid, skipping download.", datahubTariff);
 312             cacheManager.updateTariffs(datahubTariff);
 313         } else {
 314             DatahubTariffFilter filter = switch (datahubTariff) {
 315                 case GRID_TARIFF -> getGridTariffFilter();
 316                 case SYSTEM_TARIFF -> DatahubTariffFilterFactory.getSystemTariff();
 317                 case TRANSMISSION_GRID_TARIFF -> DatahubTariffFilterFactory.getTransmissionGridTariff();
 318                 case ELECTRICITY_TAX -> DatahubTariffFilterFactory.getElectricityTax();
 319                 case REDUCED_ELECTRICITY_TAX -> DatahubTariffFilterFactory.getReducedElectricityTax();
 320             };
 321             cacheManager.putTariffs(datahubTariff, downloadPriceLists(globalLocationNumber, filter));
 322         }
 323     }
 324
 325     private Collection<DatahubPricelistRecord> downloadPriceLists(GlobalLocationNumber globalLocationNumber,
 326             DatahubTariffFilter filter) throws InterruptedException, DataServiceException {
 327         Map<String, String> properties = editProperties();
 328         Collection<DatahubPricelistRecord> records = apiController.getDatahubPriceLists(globalLocationNumber,
 329                 ChargeType.Tariff, filter, properties);
 330         updateProperties(properties);
 331
 332         return records;
 333     }
 334
 335     private DatahubTariffFilter getGridTariffFilter() {
 336         Channel channel = getThing().getChannel(CHANNEL_GRID_TARIFF);
 337         if (channel == null) {
 338             return DatahubTariffFilterFactory.getGridTariffByGLN(config.gridCompanyGLN);
 339         }
 340
 341         DatahubPriceConfiguration datahubPriceConfiguration = channel.getConfiguration()
 342                 .as(DatahubPriceConfiguration.class);
 343
 344         if (!datahubPriceConfiguration.hasAnyFilterOverrides()) {
 345             return DatahubTariffFilterFactory.getGridTariffByGLN(config.gridCompanyGLN);
 346         }
 347
 348         DateQueryParameter start = datahubPriceConfiguration.getStart();
 349         if (start == null) {
 350             logger.warn("Invalid channel configuration parameter 'start' or 'offset': {} (offset: {})",
 351                     datahubPriceConfiguration.start, datahubPriceConfiguration.offset);
 352             return DatahubTariffFilterFactory.getGridTariffByGLN(config.gridCompanyGLN);
 353         }
 354
 355         Set<ChargeTypeCode> chargeTypeCodes = datahubPriceConfiguration.getChargeTypeCodes();
 356         Set<String> notes = datahubPriceConfiguration.getNotes();
 357         DatahubTariffFilter filter;
 358         if (!chargeTypeCodes.isEmpty() || !notes.isEmpty()) {
 359             // Completely override filter.
 360             filter = new DatahubTariffFilter(chargeTypeCodes, notes, start);
 361         } else {
 362             // Only override start date in pre-configured filter.
 363             filter = new DatahubTariffFilter(DatahubTariffFilterFactory.getGridTariffByGLN(config.gridCompanyGLN),
 364                     start);
 365         }
 366
 367         return new DatahubTariffFilter(filter, DateQueryParameter.of(filter.getDateQueryParameter(),
 368                 Duration.ofHours(-CacheManager.NUMBER_OF_HISTORIC_HOURS)));
 369     }
 370
 371     private void refreshCo2EmissionPrognosis() {
 372         try {
 373             updateCo2Emissions(Dataset.CO2EmissionPrognosis, CHANNEL_CO2_EMISSION_PROGNOSIS,
 374                     DateQueryParameter.of(DateQueryParameterType.UTC_NOW, Duration.ofMinutes(-5)));
 375             updateStatus(ThingStatus.ONLINE);
 376         } catch (DataServiceException e) {
 377             if (e.getHttpStatus() != 0) {
 378                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.COMMUNICATION_ERROR,
 379                         HttpStatus.getCode(e.getHttpStatus()).getMessage());
 380             } else {
 381                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.COMMUNICATION_ERROR, e.getMessage());
 382             }
 383             if (e.getCause() != null) {
 384                 logger.debug("Error retrieving CO2 emission prognosis", e);
 385             }
 386         } catch (InterruptedException e) {
 387             logger.debug("Emission prognosis refresh job interrupted");
 388             Thread.currentThread().interrupt();
 389             return;
 390         }
 391     }
 392
 393     private void refreshCo2EmissionRealtime() {
 394         try {
 395             updateCo2Emissions(Dataset.CO2Emission, CHANNEL_CO2_EMISSION_REALTIME,
 396                     DateQueryParameter.of(DateQueryParameterType.UTC_NOW,
 397                             realtimeEmissionsFetchedFirstTime ? Duration.ofMinutes(-5) : Duration.ofHours(-24)));
 398             realtimeEmissionsFetchedFirstTime = true;
 399             updateStatus(ThingStatus.ONLINE);
 400         } catch (DataServiceException e) {
 401             if (e.getHttpStatus() != 0) {
 402                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.COMMUNICATION_ERROR,
 403                         HttpStatus.getCode(e.getHttpStatus()).getMessage());
 404             } else {
 405                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.COMMUNICATION_ERROR, e.getMessage());
 406             }
 407             if (e.getCause() != null) {
 408                 logger.debug("Error retrieving CO2 realtime emissions", e);
 409             }
 410         } catch (InterruptedException e) {
 411             logger.debug("Emission realtime refresh job interrupted");
 412             Thread.currentThread().interrupt();
 413             return;
 414         }
 415     }
 416
 417     private void updateCo2Emissions(Dataset dataset, String channelId, DateQueryParameter dateQueryParameter)
 418             throws InterruptedException, DataServiceException {
 419         if (!"DK1".equals(config.priceArea) && !"DK2".equals(config.priceArea)) {
 420             // Dataset is only for Denmark.
 421             return;
 422         }
 423         Map<String, String> properties = editProperties();
 424         CO2EmissionRecord[] emissionRecords = apiController.getCo2Emissions(dataset, config.priceArea,
 425                 dateQueryParameter, properties);
 426         updateProperties(properties);
 427
 428         TimeSeries timeSeries = new TimeSeries(REPLACE);
 429         Instant now = Instant.now();
 430
 431         if (dataset == Dataset.CO2Emission && emissionRecords.length > 0) {
 432             // Records are sorted descending, first record is current.
 433             updateState(channelId, new QuantityType<>(emissionRecords[0].emission(), Units.GRAM_PER_KILOWATT_HOUR));
 434         }
 435
 436         for (CO2EmissionRecord emissionRecord : emissionRecords) {
 437             State state = new QuantityType<>(emissionRecord.emission(), Units.GRAM_PER_KILOWATT_HOUR);
 438             timeSeries.add(emissionRecord.start(), state);
 439
 440             if (dataset == Dataset.CO2EmissionPrognosis && now.compareTo(emissionRecord.start()) >= 0
 441                     && now.compareTo(emissionRecord.end()) < 0) {
 442                 updateState(channelId, state);
 443             }
 444         }
 445         sendTimeSeries(channelId, timeSeries);
 446     }
 447
 448     private void updatePrices() {
 449         cacheManager.cleanup();
 450
 451         updateCurrentSpotPrice();
 452         Arrays.stream(DatahubTariff.values())
 453                 .forEach(tariff -> updateCurrentTariff(tariff.getChannelId(), cacheManager.getTariff(tariff)));
 454
 455         reschedulePriceUpdateJob();
 456     }
 457
 458     private void updateCurrentSpotPrice() {
 459         if (!isLinked(CHANNEL_SPOT_PRICE)) {
 460             return;
 461         }
 462         BigDecimal spotPrice = cacheManager.getSpotPrice();
 463         updatePriceState(CHANNEL_SPOT_PRICE, spotPrice, config.getCurrency());
 464     }
 465
 466     private void updateCurrentTariff(String channelId, @Nullable BigDecimal tariff) {
 467         if (!isLinked(channelId)) {
 468             return;
 469         }
 470         updatePriceState(channelId, tariff, CURRENCY_DKK);
 471     }
 472
 473     private void updatePriceState(String channelID, @Nullable BigDecimal price, Currency currency) {
 474         updateState(channelID, price != null ? getEnergyPrice(price, currency) : UnDefType.UNDEF);
 475     }
 476
 477     private State getEnergyPrice(BigDecimal price, Currency currency) {
 478         String currencyCode = currency.getCurrencyCode();
 479         Unit<?> unit = CurrencyUnits.getInstance().getUnit(currencyCode);
 480         if (unit == null) {
 481             logger.trace("Currency {} is unknown, falling back to DecimalType", currency.getCurrencyCode());
 482             return new DecimalType(price);
 483         }
 484         try {
 485             return new QuantityType<>(price + " " + currencyCode + "/kWh");
 486         } catch (IllegalArgumentException e) {
 487             logger.debug("Unable to create QuantityType, falling back to DecimalType", e);
 488             return new DecimalType(price);
 489         }
 490     }
 491
 492     private void updateTimeSeries() {
 493         TimeSeries spotPriceTimeSeries = new TimeSeries(REPLACE);
 494         Map<DatahubTariff, TimeSeries> datahubTimeSeriesMap = new HashMap<>();
 495         Map<DatahubTariff, BigDecimal> datahubPreviousTariff = new HashMap<>();
 496         for (DatahubTariff datahubTariff : DatahubTariff.values()) {
 497             datahubTimeSeriesMap.put(datahubTariff, new TimeSeries(REPLACE));
 498         }
 499
 500         Map<Instant, BigDecimal> spotPriceMap = cacheManager.getSpotPrices();
 501         List<Entry<Instant, BigDecimal>> spotPrices = spotPriceMap.entrySet().stream()
 502                 .sorted(Map.Entry.comparingByKey()).toList();
 503         for (Entry<Instant, BigDecimal> spotPrice : spotPrices) {
 504             Instant hourStart = spotPrice.getKey();
 505             if (isLinked(CHANNEL_SPOT_PRICE)) {
 506                 spotPriceTimeSeries.add(hourStart, getEnergyPrice(spotPrice.getValue(), config.getCurrency()));
 507             }
 508             for (Map.Entry<DatahubTariff, TimeSeries> entry : datahubTimeSeriesMap.entrySet()) {
 509                 DatahubTariff datahubTariff = entry.getKey();
 510                 String channelId = datahubTariff.getChannelId();
 511                 if (!isLinked(channelId)) {
 512                     continue;
 513                 }
 514                 BigDecimal tariff = cacheManager.getTariff(datahubTariff, hourStart);
 515                 if (tariff != null) {
 516                     BigDecimal previousTariff = datahubPreviousTariff.get(datahubTariff);
 517                     if (previousTariff != null && tariff.equals(previousTariff)) {
 518                         // Skip redundant states.
 519                         continue;
 520                     }
 521                     TimeSeries timeSeries = entry.getValue();
 522                     timeSeries.add(hourStart, getEnergyPrice(tariff, CURRENCY_DKK));
 523                     datahubPreviousTariff.put(datahubTariff, tariff);
 524                 }
 525             }
 526         }
 527         if (spotPriceTimeSeries.size() > 0) {
 528             sendTimeSeries(CHANNEL_SPOT_PRICE, spotPriceTimeSeries);
 529         }
 530         for (Map.Entry<DatahubTariff, TimeSeries> entry : datahubTimeSeriesMap.entrySet()) {
 531             DatahubTariff datahubTariff = entry.getKey();
 532             String channelId = datahubTariff.getChannelId();
 533             if (!isLinked(channelId)) {
 534                 continue;
 535             }
 536             TimeSeries timeSeries = entry.getValue();
 537             if (timeSeries.size() > 0) {
 538                 sendTimeSeries(channelId, timeSeries);
 539             }
 540         }
 541     }
 542
 543     /**
 544      * Get the configured {@link Currency} for spot prices.
 545      *
 546      * @return Spot price currency
 547      */
 548     public Currency getCurrency() {
 549         return config.getCurrency();
 550     }
 551
 552     /**
 553      * Get cached spot prices or try once to download them if not cached
 554      * (usually if no items are linked).
 555      *
 556      * @return Map of future spot prices
 557      */
 558     public Map<Instant, BigDecimal> getSpotPrices() {
 559         try {
 560             downloadSpotPrices();
 561         } catch (DataServiceException e) {
 562             if (logger.isDebugEnabled()) {
 563                 logger.warn("Error retrieving spot prices", e);
 564             } else {
 565                 logger.warn("Error retrieving spot prices: {}", e.getMessage());
 566             }
 567         } catch (InterruptedException e) {
 568             Thread.currentThread().interrupt();
 569         }
 570
 571         return cacheManager.getSpotPrices();
 572     }
 573
 574     /**
 575      * Return cached tariffs or try once to download them if not cached
 576      * (usually if no items are linked).
 577      *
 578      * @return Map of future tariffs
 579      */
 580     public Map<Instant, BigDecimal> getTariffs(DatahubTariff datahubTariff) {
 581         try {
 582             downloadTariffs(datahubTariff);
 583         } catch (DataServiceException e) {
 584             if (logger.isDebugEnabled()) {
 585                 logger.warn("Error retrieving tariffs", e);
 586             } else {
 587                 logger.warn("Error retrieving tariffs of type {}: {}", datahubTariff, e.getMessage());
 588             }
 589         } catch (InterruptedException e) {
 590             Thread.currentThread().interrupt();
 591         }
 592
 593         return cacheManager.getTariffs(datahubTariff);
 594     }
 595
 596     /**
 597      * Return whether reduced electricity tax is set in configuration.
 598      *
 599      * @return true if reduced electricity tax applies
 600      */
 601     public boolean isReducedElectricityTax() {
 602         return config.reducedElectricityTax;
 603     }
 604
 605     private void reschedulePriceUpdateJob() {
 606         ScheduledFuture<?> priceUpdateJob = this.priceUpdateFuture;
 607         if (priceUpdateJob != null) {
 608             // Do not interrupt ourselves.
 609             priceUpdateJob.cancel(false);
 610             this.priceUpdateFuture = null;
 611         }
 612
 613         Instant now = Instant.now();
 614         long millisUntilNextClockHour = Duration
 615                 .between(now, now.plus(1, ChronoUnit.HOURS).truncatedTo(ChronoUnit.HOURS)).toMillis() + 1;
 616         this.priceUpdateFuture = scheduler.schedule(this::updatePrices, millisUntilNextClockHour,
 617                 TimeUnit.MILLISECONDS);
 618         logger.debug("Price update job rescheduled in {} milliseconds", millisUntilNextClockHour);
 619     }
 620
 621     private void reschedulePriceRefreshJob(RetryStrategy retryPolicy) {
 622         // Preserve state of previous retry policy when configuration is the same.
 623         if (!retryPolicy.equals(this.retryPolicy)) {
 624             this.retryPolicy = retryPolicy;
 625         }
 626
 627         ScheduledFuture<?> refreshJob = this.refreshPriceFuture;
 628
 629         long secondsUntilNextRefresh = this.retryPolicy.getDuration().getSeconds();
 630         Instant timeOfNextRefresh = Instant.now().plusSeconds(secondsUntilNextRefresh);
 631         this.refreshPriceFuture = scheduler.schedule(this::refreshElectricityPrices, secondsUntilNextRefresh,
 632                 TimeUnit.SECONDS);
 633         logger.debug("Price refresh job rescheduled in {} seconds: {}", secondsUntilNextRefresh, timeOfNextRefresh);
 634         DateTimeFormatter formatter = DateTimeFormatter.ofPattern(PROPERTY_DATETIME_FORMAT);
 635         updateProperty(PROPERTY_NEXT_CALL, LocalDateTime.ofInstant(timeOfNextRefresh, timeZoneProvider.getTimeZone())
 636                 .truncatedTo(ChronoUnit.SECONDS).format(formatter));
 637
 638         if (refreshJob != null) {
 639             refreshJob.cancel(true);
 640         }
 641     }
 642
 643     private void rescheduleEmissionPrognosisJob() {
 644         logger.debug("Scheduling emission prognosis refresh job now and every {}", emissionPrognosisJobInterval);
 645
 646         ScheduledFuture<?> refreshEmissionPrognosisFuture = this.refreshEmissionPrognosisFuture;
 647         if (refreshEmissionPrognosisFuture != null) {
 648             refreshEmissionPrognosisFuture.cancel(true);
 649         }
 650
 651         this.refreshEmissionPrognosisFuture = scheduler.scheduleWithFixedDelay(this::refreshCo2EmissionPrognosis, 0,
 652                 emissionPrognosisJobInterval.toSeconds(), TimeUnit.SECONDS);
 653     }
 654
 655     private void rescheduleEmissionRealtimeJob() {
 656         logger.debug("Scheduling emission realtime refresh job now and every {}", emissionRealtimeJobInterval);
 657
 658         ScheduledFuture<?> refreshEmissionFuture = this.refreshEmissionRealtimeFuture;
 659         if (refreshEmissionFuture != null) {
 660             refreshEmissionFuture.cancel(true);
 661         }
 662
 663         this.refreshEmissionRealtimeFuture = scheduler.scheduleWithFixedDelay(this::refreshCo2EmissionRealtime, 0,
 664                 emissionRealtimeJobInterval.toSeconds(), TimeUnit.SECONDS);
 665     }
 666 }