[weather] refactor: migrate to server-side providers with centralized HTTPFetcher

defaultmodules/utils.js

@@ -1,154 +1,3 @@
-/**
- * A function to make HTTP requests via the server to avoid CORS-errors.
- * @param {string} url the url to fetch from
- * @param {string} type what content-type to expect in the response, can be "json" or "xml"
- * @param {boolean} useCorsProxy A flag to indicate
- * @param {Array.<{name: string, value:string}>} requestHeaders the HTTP headers to send
- * @param {Array.<string>} expectedResponseHeaders the expected HTTP headers to receive
- * @param {string} basePath The base path, default is "/"
- * @returns {Promise} resolved when the fetch is done. The response headers is placed in a headers-property (provided the response does not already contain a headers-property).
- */
-async function performWebRequest (url, type = "json", useCorsProxy = false, requestHeaders = undefined, expectedResponseHeaders = undefined, basePath = "/") {
-	const request = {};
-	let requestUrl;
-	if (useCorsProxy) {
-		requestUrl = getCorsUrl(url, requestHeaders, expectedResponseHeaders, basePath);
-	} else {
-		requestUrl = url;
-		request.headers = getHeadersToSend(requestHeaders);
-	}
-
-	try {
-		const response = await fetch(requestUrl, request);
-		if (response.ok) {
-			const data = await response.text();
-
-			if (type === "xml") {
-				return new DOMParser().parseFromString(data, "text/html");
-			} else {
-				if (!data || !data.length > 0) return undefined;
-
-				const dataResponse = JSON.parse(data);
-				if (!dataResponse.headers) {
-					dataResponse.headers = getHeadersFromResponse(expectedResponseHeaders, response);
-				}
-				return dataResponse;
-			}
-		} else {
-			throw new Error(`Response status: ${response.status}`);
-		}
-	} catch (error) {
-		Log.error(`Error fetching data from ${url}: ${error}`);
-		return undefined;
-	}
-}
-
-/**
- * Gets a URL that will be used when calling the CORS-method on the server.
- * @param {string} url the url to fetch from
- * @param {Array.<{name: string, value:string}>} requestHeaders the HTTP headers to send
- * @param {Array.<string>} expectedResponseHeaders the expected HTTP headers to receive
- * @param {string} basePath The base path, default is "/"
- * @returns {string} to be used as URL when calling CORS-method on server.
- */
-const getCorsUrl = function (url, requestHeaders, expectedResponseHeaders, basePath = "/") {
-	if (!url || url.length < 1) {
-		throw new Error(`Invalid URL: ${url}`);
-	} else {
-		let corsUrl = `${location.protocol}//${location.host}${basePath}cors?`;
-
-		const requestHeaderString = getRequestHeaderString(requestHeaders);
-		if (requestHeaderString) corsUrl = `${corsUrl}sendheaders=${requestHeaderString}`;
-
-		const expectedResponseHeadersString = getExpectedResponseHeadersString(expectedResponseHeaders);
-		if (requestHeaderString && expectedResponseHeadersString) {
-			corsUrl = `${corsUrl}&expectedheaders=${expectedResponseHeadersString}`;
-		} else if (expectedResponseHeadersString) {
-			corsUrl = `${corsUrl}expectedheaders=${expectedResponseHeadersString}`;
-		}
-
-		if (requestHeaderString || expectedResponseHeadersString) {
-			return `${corsUrl}&url=${url}`;
-		}
-		return `${corsUrl}url=${url}`;
-	}
-};
-
-/**
- * Gets the part of the CORS URL that represents the HTTP headers to send.
- * @param {Array.<{name: string, value:string}>} requestHeaders the HTTP headers to send
- * @returns {string} to be used as request-headers component in CORS URL.
- */
-const getRequestHeaderString = function (requestHeaders) {
-	let requestHeaderString = "";
-	if (requestHeaders) {
-		for (const header of requestHeaders) {
-			if (requestHeaderString.length === 0) {
-				requestHeaderString = `${header.name}:${encodeURIComponent(header.value)}`;
-			} else {
-				requestHeaderString = `${requestHeaderString},${header.name}:${encodeURIComponent(header.value)}`;
-			}
-		}
-		return requestHeaderString;
-	}
-	return undefined;
-};
-
-/**
- * Gets headers and values to attach to the web request.
- * @param {Array.<{name: string, value:string}>} requestHeaders the HTTP headers to send
- * @returns {object} An object specifying name and value of the headers.
- */
-const getHeadersToSend = (requestHeaders) => {
-	const headersToSend = {};
-	if (requestHeaders) {
-		for (const header of requestHeaders) {
-			headersToSend[header.name] = header.value;
-		}
-	}
-
-	return headersToSend;
-};
-
-/**
- * Gets the part of the CORS URL that represents the expected HTTP headers to receive.
- * @param {Array.<string>} expectedResponseHeaders the expected HTTP headers to receive
- * @returns {string} to be used as the expected HTTP-headers component in CORS URL.
- */
-const getExpectedResponseHeadersString = function (expectedResponseHeaders) {
-	let expectedResponseHeadersString = "";
-	if (expectedResponseHeaders) {
-		for (const header of expectedResponseHeaders) {
-			if (expectedResponseHeadersString.length === 0) {
-				expectedResponseHeadersString = `${header}`;
-			} else {
-				expectedResponseHeadersString = `${expectedResponseHeadersString},${header}`;
-			}
-		}
-		return expectedResponseHeaders;
-	}
-	return undefined;
-};
-
-/**
- * Gets the values for the expected headers from the response.
- * @param {Array.<string>} expectedResponseHeaders the expected HTTP headers to receive
- * @param {Response} response the HTTP response
- * @returns {string} to be used as the expected HTTP-headers component in CORS URL.
- */
-const getHeadersFromResponse = (expectedResponseHeaders, response) => {
-	const responseHeaders = [];
-
-	if (expectedResponseHeaders) {
-		for (const header of expectedResponseHeaders) {
-			const headerValue = response.headers.get(header);
-			responseHeaders.push({ name: header, value: headerValue });
-		}
-	}
-
-	return responseHeaders;
-};
-
 /**
  * Format the time according to the config
  * @param {object} config The config of the module
@@ -178,6 +27,5 @@ const formatTime = (config, time) => {
 };
 
 if (typeof module !== "undefined") module.exports = {
-	performWebRequest,
 	formatTime
 };

defaultmodules/weather/current.njk

@@ -25,7 +25,7 @@
       {% if config.showHumidity === "wind" %}
         {{ humidity() }}
       {% endif %}
-      {% if config.showSun %}
+      {% if config.showSun and current.nextSunAction() %}
         <span class="wi dimmed wi-{{ current.nextSunAction() }}"></span>
         <span>
           {% if current.nextSunAction() === "sunset" %}

defaultmodules/weather/node_helper.js

@@ -0,0 +1,103 @@
+const path = require("node:path");
+const NodeHelper = require("node_helper");
+const Log = require("logger");
+
+module.exports = NodeHelper.create({
+	providers: {},
+
+	start () {
+		Log.log(`Starting node helper for: ${this.name}`);
+	},
+
+	socketNotificationReceived (notification, payload) {
+		if (notification === "INIT_WEATHER") {
+			Log.log(`Received INIT_WEATHER for instance ${payload.instanceId}`);
+			this.initWeatherProvider(payload);
+		} else if (notification === "STOP_WEATHER") {
+			Log.log(`Received STOP_WEATHER for instance ${payload.instanceId}`);
+			this.stopWeatherProvider(payload.instanceId);
+		}
+		// FETCH_WEATHER is no longer needed - HTTPFetcher handles periodic fetching
+	},
+
+	/**
+	 * Initialize a weather provider
+	 * @param {object} config The configuration object
+	 */
+	async initWeatherProvider (config) {
+		const identifier = config.weatherProvider.toLowerCase();
+		const instanceId = config.instanceId;
+
+		Log.log(`Attempting to initialize provider ${identifier} for instance ${instanceId}`);
+
+		if (this.providers[instanceId]) {
+			Log.log(`Weather provider ${identifier} already initialized for instance ${instanceId}`);
+			return;
+		}
+
+		try {
+			// Dynamically load the provider module
+			const providerPath = path.join(__dirname, "providers", `${identifier}.js`);
+			Log.log(`Loading provider from: ${providerPath}`);
+			const ProviderClass = require(providerPath);
+
+			// Create provider instance
+			const provider = new ProviderClass(config);
+
+			// Set up callbacks before initializing
+			provider.setCallbacks(
+				(data) => {
+					// On data received
+					this.sendSocketNotification("WEATHER_DATA", {
+						instanceId,
+						type: config.type,
+						data
+					});
+				},
+				(errorInfo) => {
+					// On error
+					this.sendSocketNotification("WEATHER_ERROR", {
+						instanceId,
+						error: errorInfo.message || "Unknown error",
+						translationKey: errorInfo.translationKey
+					});
+				}
+			);
+
+			await provider.initialize();
+			this.providers[instanceId] = provider;
+
+			this.sendSocketNotification("WEATHER_INITIALIZED", {
+				instanceId,
+				locationName: provider.locationName
+			});
+
+			// Start periodic fetching
+			provider.start();
+
+			Log.log(`Weather provider ${identifier} initialized for instance ${instanceId}`);
+		} catch (error) {
+			Log.error(`Failed to initialize weather provider ${identifier}:`, error);
+			this.sendSocketNotification("WEATHER_ERROR", {
+				instanceId,
+				error: error.message
+			});
+		}
+	},
+
+	/**
+	 * Stop and cleanup a weather provider
+	 * @param {string} instanceId The instance identifier
+	 */
+	stopWeatherProvider (instanceId) {
+		const provider = this.providers[instanceId];
+
+		if (provider) {
+			Log.log(`Stopping weather provider for instance ${instanceId}`);
+			provider.stop();
+			delete this.providers[instanceId];
+		} else {
+			Log.warn(`No provider found for instance ${instanceId}`);
+		}
+	}
+});