Decide REST or state

Author: llbbdd

dist/Predbat-Table-Card-Next.js

@@ -2,39 +2,49 @@ import { RawData, PredbatRawDataSchema } from '../schemas/predbat';
 
 export class PredbatService {
   private _dataCallback: ((validatedHistoricPlanData: RawData, validatedPlanData: RawData) => void) | null;
-  private _port: number;
-  private _updateInterval: ReturnType<typeof setInterval> | null = null;
-  private _retryTimeout: ReturnType<typeof setTimeout> | null = null;
-  private _isAvailable = false;
-  private _fetchInProgress = false;
+  private _portRestApi: number;
+  private _updateIntervalRestApi: ReturnType<typeof setInterval> | null = null;
+  private _retryTimeoutRestApi: ReturnType<typeof setTimeout> | null = null;
+  private _isAvailableRestApi = false;
+  private _fetchInProgressRestApi = false;
+  private _dataSource: 'REST_API' | 'HASS_STATES' | null = null;
 
   public constructor(port: number, dataCallback: (validatedHistoricPlanData: RawData, validatedPlanData: RawData) => void) {
-    this._port = port;
+    this._portRestApi = port;
     this._dataCallback = dataCallback;
-    this._startPolling();
+
+    this._getDataSource(port)
+      .then((dataSource) => {
+        this._dataSource = dataSource;
+
+        if (this._dataSource === 'REST_API') this._startPollingRestApi();
+      })
+      .catch((error) => {
+        throw error;
+      });
   }
 
-  private _startPolling(): void {
-    this._fetchData();
+  private _startPollingRestApi(): void {
+    this._fetchDataRestApi();
 
-    this._retryTimeout = setInterval(() => {
-      if (!this._isAvailable && !this._fetchInProgress) {
-        this._fetchData();
+    this._retryTimeoutRestApi = setInterval(() => {
+      if (!this._isAvailableRestApi && !this._fetchInProgressRestApi) {
+        this._fetchDataRestApi();
       }
-      else if (this._isAvailable) {
-        if (this._retryTimeout) {
-          clearInterval(this._retryTimeout);
-          this._retryTimeout = null;
+      else if (this._isAvailableRestApi) {
+        if (this._retryTimeoutRestApi) {
+          clearInterval(this._retryTimeoutRestApi);
+          this._retryTimeoutRestApi = null;
         }
       }
     }, 1000);
   }
 
-  private _fetchData(): void {
-    if (this._fetchInProgress) return;
-    this._fetchInProgress = true;
+  private _fetchDataRestApi(): void {
+    if (this._fetchInProgressRestApi) return;
+    this._fetchInProgressRestApi = true;
 
-    this._getPlanData(this._port)
+    this._getPlanDataRestApi(this._portRestApi)
       .then((planData) => {
         if (planData?.yesterday === undefined) {
           console.warn('No data received from Predbat API');
@@ -54,32 +64,32 @@ export class PredbatService {
           console.error(error);
         }
 
-        if (!this._isAvailable) {
+        if (!this._isAvailableRestApi) {
           console.info('Successfully fetched Predbat API data');
 
-          this._isAvailable = true;
-          this._scheduleHalfHourUpdate(5);
+          this._isAvailableRestApi = true;
+          this._scheduleHalfHourUpdateRestApi(5);
         }
       })
       .catch((error) => {
-        if (this._isAvailable) {
+        if (this._isAvailableRestApi) {
           console.warn('Predbat API request failed, will retry...', error.message);
 
-          this._isAvailable = false;
-          this._startPolling();
+          this._isAvailableRestApi = false;
+          this._startPollingRestApi();
         }
         else {
           console.error('Predbat is unreachable');
         }
       })
       .finally(() => {
-        this._fetchInProgress = false;
+        this._fetchInProgressRestApi = false;
       });
   }
 
-  private _scheduleHalfHourUpdate(updateIntervalMinutes: number): void {
-    if (this._updateInterval) {
-      clearInterval(this._updateInterval);
+  private _scheduleHalfHourUpdateRestApi(updateIntervalMinutes: number): void {
+    if (this._updateIntervalRestApi) {
+      clearInterval(this._updateIntervalRestApi);
     }
 
     const now = new Date();
@@ -92,15 +102,15 @@ export class PredbatService {
     const delay = nextUpdate.getTime() - now.getTime() + 5000;
 
     setTimeout(() => {
-      this._fetchData();
-      this._updateInterval = setInterval(() => {
-        this._fetchData();
+      this._fetchDataRestApi();
+      this._updateIntervalRestApi = setInterval(() => {
+        this._fetchDataRestApi();
       }, updateIntervalMinutes * 60 * 1000);
     }, delay);
   }
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private _getPlanData(port: number): Promise<any> {
+  private _getPlanDataRestApi(port: number): Promise<any> {
     return fetch(`http://${window.location.hostname}:${port}/api/plan_data`)
       .then((response) => response.json())
       .then((data) => data)
@@ -109,15 +119,35 @@ export class PredbatService {
       });
   }
 
+  private _getDataSource(port: number): Promise<'REST_API' | 'HASS_STATES'> {
+    return fetch(`http://${window.location.hostname}:${port}/api/plan_data`)
+      .then((response): 'REST_API' | 'HASS_STATES' => {
+        console.info('Using REST API for Predbat data');
+
+        if (response.ok) return 'REST_API';
+
+        console.info('Using HASS state for Predbat data (response error)');
+
+        return 'HASS_STATES';
+      })
+      .catch((): 'HASS_STATES' => {
+        console.info('Using HASS state for Predbat data (fetch error)');
+
+        return 'HASS_STATES';
+      });
+  }
+
   public disconnect(): void {
-    if (this._retryTimeout) {
-      clearInterval(this._retryTimeout);
-      this._retryTimeout = null;
+    if (this._retryTimeoutRestApi) {
+      clearInterval(this._retryTimeoutRestApi);
+      this._retryTimeoutRestApi = null;
     }
-    if (this._updateInterval) {
-      clearInterval(this._updateInterval);
-      this._updateInterval = null;
+
+    if (this._updateIntervalRestApi) {
+      clearInterval(this._updateIntervalRestApi);
+      this._updateIntervalRestApi = null;
     }
-    this._isAvailable = false;
+
+    this._isAvailableRestApi = false;
   }
 }