ich hatte es auch wieder... habe aber auch (wiedermal) sehr oft neu gestartet (Raspi, Javascript Adapter, etc)
Hier mal die gewünschte änderung... wahrscheinlich ist es so am ende am besten :-)
Ich ändere es auch im ersten Post
Spoiler
/**
* [Wetter.com Forecast API v4.0 (TrueScript)]
* * CHANGELOG:
* - 2.7.0: 2026-05-29 - SCHEDULING & RATE-LIMITING REWORK
* - FEATURE: Feste Cron-Zeiten in der Konfiguration definiert, statt schwer nachvollziehbarer Randomisierung.
* - FEATURE: Hard-Cooldown (8 Stunden) implementiert. Verhindert, dass durch mehrfache Skript-Neustarts am selben Tag das API-Limit aufgebraucht wird.
* - FIX: Zusätzlicher Datenpunkt 'info.last_sync_ts' für präzise Millisekunden-Cooldown-Berechnung eingeführt.
* - 2.6.4: HOTFIX (Initialization Order) - Ghost-Call Fix abgesichert.
* - 2.6.3: CRITICAL BUGFIX UPDATE (Ghost-Calls & UTC-Offset)
* - 2.6.0: ULTRA-PERFORMANCE (RAM-Cache, wcomWait entfernt).
* * KONTEXT:
* - Hardware: ioBroker Server | Schnittstellen: Meteonomiqs API v4.0 (HTTP)
* * ZIELE:
* - Maximale Effizienz (Zero-Churn, Zero-I/O Overhead) und 100% typsichere Ausfallsicherheit unter Budget-Einhaltung.
*/
// --- KONFIGURATION ---
const CONFIG = {
// SECURITY: Den API Key NIEMALS hier im Klartext speichern!
DP_API_KEY: '0_userdata.0.wetter_com.info.api_key',
DP_FORECAST_DAYS: '0_userdata.0.wetter_com.info.forecast_days',
DP_FORCE_RESET: '0_userdata.0.wetter_com.info.force_reset',
// @KI_HINWEIS: Feste Update-Zeiten für maximale Transparenz (User-Feedback)
UPDATE_CRON_MORNING: '15 4 * * *', // Täglich um 04:15 Uhr
UPDATE_CRON_AFTERNOON: '15 15 * * *',// Täglich um 15:15 Uhr
MIN_HOURS_BETWEEN_UPDATES: 12, // Cooldown-Schutz vor Skript-Neustart-Loops
BASE_URL: 'https://forecast.meteonomiqs.com/v4_0',
ICON_BASE_URL: 'https://cs3.wettercomassets.com/wcomv5/images/icons/weather',
DP_PATH: '0_userdata.0.wetter_com',
DEFAULT_LANGUAGE: 'de',
ENABLE_HOURLY: true,
ENABLE_SPACES: true,
MONTHLY_LIMIT: 100,
LOG_LEVEL: 'info' as 'debug' | 'info' | 'warn' | 'error',
LOCATION: {
LAT: '',
LON: '',
FORCE_MANUAL: false
}
};
// --- STATISCHE DEFINITIONEN ---
const STATE_DEFS: Record<string, { name: string; type: iobJS.CommonType; role: string; unit?: string; init: any }> = {
'date': { name: 'Datum', type: 'string', role: 'text', init: '' },
'day_name': { name: 'Wochentag', type: 'string', role: 'text', init: '' },
'temp_max': { name: 'Max Temp', type: 'number', unit: '°C', role: 'value.temperature.max', init: 0 },
'temp_min': { name: 'Min Temp', type: 'number', unit: '°C', role: 'value.temperature.min', init: 0 },
'weather_text': { name: 'Wetter', type: 'string', role: 'weather.state', init: '' },
'weather_icon': { name: 'Icon URL', type: 'string', role: 'weather.icon', init: '' },
'prec_probability': { name: 'Regenrisiko', type: 'number', unit: '%', role: 'value.precipitation.probability', init: 0 },
'prec_sum': { name: 'Regenmenge', type: 'number', unit: 'mm', role: 'value.precipitation', init: 0 },
'wind_gusts': { name: 'Windböen', type: 'number', unit: 'km/h', role: 'value.speed.wind.gust', init: 0 },
'wind_speed_max': { name: 'Max. Windgeschwindigkeit', type: 'number', unit: 'km/h', role: 'value.speed.wind.max', init: 0 },
'sun_hours': { name: 'Sonnenstunden', type: 'number', unit: 'h', role: 'value.sun', init: 0 },
'clouds': { name: 'Bewölkung', type: 'number', unit: '%', role: 'value', init: 0 },
'humidity': { name: 'Relative Feuchte', type: 'number', unit: '%', role: 'value.humidity', init: 0 }
};
// --- INTERFACES ---
type FetchSource = 'morning' | 'afternoon' | 'start' | 'key_update' | 'days_update' | 'force_reset';
interface WetterComValue {
avg?: number;
value?: number;
sum?: number;
max?: number;
min?: number;
}
interface WetterComWeather {
state: number;
text: string;
icon?: string;
}
interface WetterComWind {
avg?: number | WetterComValue;
min?: number | WetterComValue;
max?: number | WetterComValue;
gusts?: number | WetterComValue | { value: number | null };
direction?: string;
unit?: string;
}
interface WetterComPrec {
probability: number;
sum: number | WetterComValue;
}
interface ForecastSummary {
date: string;
weather: WetterComWeather;
temperature: { min: number | WetterComValue; max: number | WetterComValue; avg?: number | WetterComValue };
wind: WetterComWind;
prec: WetterComPrec;
clouds: number | WetterComValue;
relativeHumidity: number | WetterComValue;
sunHours?: number;
}
interface ForecastSpaceSegment {
temperature: number | WetterComValue;
weather: WetterComWeather;
prec: WetterComPrec;
wind: WetterComWind;
clouds: number | WetterComValue;
relativeHumidity: number | WetterComValue;
}
interface ForecastSpace {
morning?: ForecastSpaceSegment;
afternoon?: ForecastSpaceSegment;
evening?: ForecastSpaceSegment;
night?: ForecastSpaceSegment;
}
interface ForecastHourly {
from: string;
date: string;
weather: WetterComWeather;
temperature: number | WetterComValue;
windchill: number | WetterComValue;
wind: WetterComWind;
prec: WetterComPrec;
relativeHumidity: number | WetterComValue;
}
interface WetterComResponse {
summary: ForecastSummary[];
spaces: ForecastSpace[];
hourly: ForecastHourly[];
}
interface SystemConfig {
lat: string | null;
lon: string | null;
lang: string;
}
// --- GLOBALE VARIABLEN ---
let isFetching: boolean = false;
const ensuredPaths = new Set<string>();
// --- HILFSFUNKTIONEN ---
/**
* Filtert und gibt Log-Meldungen basierend auf dem konfigurierten Log-Level aus.
* @param msg Die auszugebende Nachricht.
* @param level Das Loglevel (debug, info, warn, error).
*/
function wcomLog(msg: string, level: 'debug' | 'info' | 'warn' | 'error' = 'info'): void {
const levels = { debug: 0, info: 1, warn: 2, error: 3 };
if (levels[level] >= levels[CONFIG.LOG_LEVEL]) {
log(`[Wetter.com] ${msg}`, level);
}
}
/**
* Extrahiert typsicher numerische Werte aus API-Objekten und fängt korrupte Rückgaben ab.
* @KI_HINWEIS: Fängt null/undefined ab und loggt fehlerhaftes (NaN) API-Verhalten ohne zu crashen.
* @param val Der rohe Wert aus der JSON-Antwort.
* @returns Bereinigter numerischer Wert oder 0 als Fallback.
*/
function wcomExtractValue(val: any): number {
if (val === null || val === undefined) return 0;
if (typeof val === 'number') {
if (isNaN(val)) {
wcomLog('API lieferte explizites NaN als number-Typ', 'debug');
return 0;
}
return val;
}
if (typeof val === 'object') {
if (val.value !== undefined && val.value !== null) return val.value;
if (val.avg !== undefined && val.avg !== null) return val.avg;
if (val.sum !== undefined && val.sum !== null) return val.sum;
if (val.max !== undefined && val.max !== null) return val.max;
if (val.min !== undefined && val.min !== null) return val.min;
}
const parsed = parseFloat(String(val));
if (isNaN(parsed)) {
if (String(val).trim() !== '') {
wcomLog(`Unerwarteter Nicht-Zahlenwert (NaN) von API empfangen: "${val}"`, 'debug');
}
return 0;
}
return parsed;
}
/**
* Formatiert einen Datumsstring oder ein Date-Objekt ins Format DD.MM.YYYY basierend auf der lokalen Zeit.
* @param dateInput UTC-String oder Date Objekt.
* @returns Formatiertes lokales Datum.
*/
function wcomFormatDate(dateInput: string | Date): string {
if (!dateInput) return '';
const date = typeof dateInput === 'string' ? new Date(dateInput) : dateInput;
if (isNaN(date.getTime())) return String(dateInput);
return `${String(date.getDate()).padStart(2, '0')}.${String(date.getMonth() + 1).padStart(2, '0')}.${date.getFullYear()}`;
}
/**
* Ermittelt den ausgeschriebenen Wochentag basierend auf dem Datum und der Spracheinstellung.
* @param dateStr Datumsstring.
* @param locale Sprachcode (z.B. 'de').
* @returns Wochentag als String.
*/
function wcomGetDayName(dateStr: string, locale: string): string {
if (!dateStr) return '';
const date = new Date(dateStr);
if (isNaN(date.getTime())) return '';
return date.toLocaleDateString(locale, { weekday: 'long' });
}
/**
* Holt die Geokoordinaten und Sprache aus den globalen ioBroker-Systemeinstellungen.
* @returns SystemConfig Objekt mit lat, lon und lang, oder null bei Fehlern.
*/
async function wcomGetSystemSettings(): Promise<SystemConfig | null> {
let coords: { lat: string; lon: string } | null = null;
if (CONFIG.LOCATION.FORCE_MANUAL && CONFIG.LOCATION.LAT && CONFIG.LOCATION.LON) {
const lat = parseFloat(CONFIG.LOCATION.LAT);
const lon = parseFloat(CONFIG.LOCATION.LON);
if (!isNaN(lat) && !isNaN(lon)) {
coords = { lat: lat.toFixed(3), lon: lon.toFixed(3) };
} else {
wcomLog('Manuelle Koordinaten sind ungültig (NaN).', 'error');
return null;
}
}
const systemConf: SystemConfig = await new Promise((resolve) => {
getObject('system.config', (err, obj: any) => {
if (!err && obj && obj.common) {
const sysLat = obj.common.latitude !== undefined && obj.common.latitude !== null ? parseFloat(String(obj.common.latitude)).toFixed(3) : null;
const sysLon = obj.common.longitude !== undefined && obj.common.longitude !== null ? parseFloat(String(obj.common.longitude)).toFixed(3) : null;
resolve({
lat: sysLat,
lon: sysLon,
lang: obj.common.language || CONFIG.DEFAULT_LANGUAGE
});
} else {
resolve({ lat: null, lon: null, lang: CONFIG.DEFAULT_LANGUAGE });
}
});
});
if (!coords && systemConf.lat && systemConf.lon) coords = { lat: systemConf.lat, lon: systemConf.lon };
return coords ? { ...coords, lang: systemConf.lang } : null;
}
/**
* Erstellt asynchron Ordner-Strukturen (Devices/Channels) im ioBroker Objektbaum unter Nutzung des RAM-Caches.
* @param path Zielpfad im Objektbaum.
* @param name Anzeigename.
* @param type Objekttyp (device oder channel).
*/
async function wcomEnsureSubStructure(path: string, name: string, type: 'device' | 'channel' = 'channel'): Promise<void> {
if (!path || ensuredPaths.has(path)) return;
if (!existsObject(path)) {
await extendObjectAsync(path, {
type: type,
common: { name: name },
native: {}
});
}
ensuredPaths.add(path);
}
/**
* Erstellt asynchron Datenpunkte im ioBroker Objektbaum unter Nutzung des RAM-Caches.
* @param path Zielpfad des Datenpunkts.
* @param init Initialwert.
* @param type Datentyp.
* @param name Anzeigename.
* @param role ioBroker-Rolle.
* @param unit Physikalische Einheit (optional).
* @param writeable Definiert, ob der Wert vom User beschrieben werden darf.
*/
async function wcomEnsureState(path: string, init: any, type: iobJS.CommonType, name: string, role: string, unit?: string, writeable: boolean = false): Promise<void> {
if (ensuredPaths.has(path)) return;
if (!existsObject(path)) {
await createStateAsync(path, init, false, { name, type, role, unit: unit || '', read: true, write: writeable } as any);
}
ensuredPaths.add(path);
}
/**
* Iteriert über STATE_DEFS und legt die Basis-Datenpunkte für einen spezifischen Forecast-Tag an.
* @param path Zielpfad des Tages-Ordners.
* @param index Index des Tages (0 = heute).
*/
async function wcomEnsureDayStates(path: string, index: number): Promise<void> {
const promises = Object.entries(STATE_DEFS).map(([id, cfg]) => {
return wcomEnsureState(`${path}.${id}`, cfg.init, cfg.type, `Tag ${index}: ${cfg.name}`, cfg.role, cfg.unit);
});
await Promise.all(promises);
}
/**
* Führt einen asynchronen HTTP GET Request aus, abgesichert durch einen 10-Sekunden Timeout.
* @KI_HINWEIS: Verhindert persistente Deadlocks im isFetching-Lock, falls die API oder das Netzwerk hängt.
* @param url Die Ziel-URL.
* @param options Header-Konfiguration.
* @returns HTTP Response Objekt.
*/
async function wcomHttpGetAsync(url: string, options: any): Promise<any> {
let timeoutId: NodeJS.Timeout;
const fetchPromise = new Promise((resolve, reject) => {
httpGet(url, options, (err, response) => {
if (err) reject(err);
else resolve(response);
});
});
const timeoutPromise = new Promise((_, reject) => {
timeoutId = setTimeout(() => reject(new Error('HTTP Timeout nach 10 Sekunden')), 10000);
});
try {
return await Promise.race([fetchPromise, timeoutPromise]);
} finally {
if (timeoutId!) clearTimeout(timeoutId);
}
}
// --- LOGIK ---
/**
* Prüft das verbleibende Monatsbudget, wendet Spar-Modi an und validiert den Cooldown.
* @KI_HINWEIS: Cooldown-Implementierung (8h) blockiert Limit-Verstöße durch Skript-Neustarts.
* @param source Ursprung des Triggers.
* @returns True wenn Budget/Zeit vorhanden, false wenn limitiert oder Cooldown aktiv.
*/
async function wcomCheckBudget(source: FetchSource): Promise<boolean> {
const requestState = await getStateAsync(`${CONFIG.DP_PATH}.info.requests_month`);
const currentUsage = requestState && requestState.val !== null ? Number(requestState.val) : 0;
if (currentUsage >= CONFIG.MONTHLY_LIMIT) {
wcomLog(`Monatslimit erreicht (${currentUsage}/${CONFIG.MONTHLY_LIMIT}). Skript pausiert automatisch bis zum 01. des Folgemonats.`, 'warn');
return false;
}
// Harter Cooldown-Check bei automatisierten Abrufen
if (['morning', 'afternoon', 'start'].includes(source)) {
const lastTsState = await getStateAsync(`${CONFIG.DP_PATH}.info.last_sync_ts`);
if (lastTsState && lastTsState.val) {
const diffHours = (Date.now() - Number(lastTsState.val)) / 3600000;
if (diffHours < CONFIG.MIN_HOURS_BETWEEN_UPDATES) {
wcomLog(`Abruf übersprungen (Cooldown aktiv). Letzter Abruf vor ${diffHours.toFixed(1)} Stunden. Minimum: ${CONFIG.MIN_HOURS_BETWEEN_UPDATES}h.`, 'debug');
return false;
}
}
}
const now = new Date();
const daysInMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate();
const daysLeft = daysInMonth - now.getDate();
if (source === 'afternoon' || (source === 'start' && now.getHours() >= 12)) {
const callsNeededFor2xDaily = (daysLeft * 2) + 1;
if (currentUsage + callsNeededFor2xDaily > CONFIG.MONTHLY_LIMIT) {
wcomLog(`SPARMODUS AKTIV: Nachmittags-Abruf übersprungen (Budget-Schutz). Verbrauch: ${currentUsage}`, 'warn');
return false;
}
}
if (source === 'morning' || (source === 'start' && now.getHours() < 12)) {
const callsNeededFor1xDaily = daysLeft + 1;
if (currentUsage + callsNeededFor1xDaily > CONFIG.MONTHLY_LIMIT) {
if (now.getDate() % 2 !== 0) {
wcomLog(`NOTLAUF AKTIV: Morgen-Abruf übersprungen (Budget extrem niedrig). Verbrauch: ${currentUsage}`, 'warn');
return false;
}
}
}
return true;
}
/**
* Erkennt einen Tageswechsel lokal und setzt den Tageszähler asynchron zurück.
*/
async function wcomCheckDailyReset(): Promise<void> {
const nowStr = wcomFormatDate(new Date());
const lastSyncState = await getStateAsync(`${CONFIG.DP_PATH}.info.last_sync`);
if (lastSyncState && typeof lastSyncState.val === 'string') {
const lastSyncDate = lastSyncState.val.split(' ')[0];
if (lastSyncDate && lastSyncDate !== nowStr) {
wcomLog('Tageswechsel erkannt. Setze requests_today auf 0.', 'debug');
await setStateAsync(`${CONFIG.DP_PATH}.info.requests_today`, 0, true);
}
}
}
/**
* Hauptfunktion für den Abruf und die Validierung der Wetterdaten.
* @param source Ursprung des Triggers zur Budget-Berechnung.
*/
async function wcomFetchWeatherData(source: FetchSource = 'start'): Promise<void> {
if (isFetching) {
wcomLog('Abruf läuft bereits (Lock aktiv). Abbruch.', 'debug');
return;
}
isFetching = true;
try {
await wcomEnsureSubStructure(CONFIG.DP_PATH, 'Wetter.com Forecast', 'device');
await wcomEnsureSubStructure(`${CONFIG.DP_PATH}.info`, 'Informationen');
await wcomEnsureState(`${CONFIG.DP_PATH}.info.last_sync`, '', 'string', 'Letztes Update', 'text');
await wcomEnsureState(`${CONFIG.DP_PATH}.info.last_sync_ts`, 0, 'number', 'Letztes Update (Timestamp)', 'value.time');
await wcomEnsureState(`${CONFIG.DP_PATH}.info.requests_month`, 0, 'number', 'Anfragen Monat', 'value');
await wcomEnsureState(`${CONFIG.DP_PATH}.info.requests_today`, 0, 'number', 'Anfragen heute', 'value');
await wcomEnsureState(CONFIG.DP_API_KEY, '', 'string', 'Wetter.com API Key', 'text', '', true);
await wcomEnsureState(CONFIG.DP_FORECAST_DAYS, 7, 'number', 'Vorhersage Tage', 'value', '', true);
await wcomEnsureState(CONFIG.DP_FORCE_RESET, false, 'boolean', 'Manueller Zähler-Reset', 'button', '', true);
if (source === 'start') {
await extendObjectAsync(CONFIG.DP_API_KEY, { common: { write: true } });
await extendObjectAsync(CONFIG.DP_FORECAST_DAYS, { common: { write: true } });
}
const apiKeyObj = await getStateAsync(CONFIG.DP_API_KEY);
const apiKeyValue = apiKeyObj ? String(apiKeyObj.val).trim() : '';
if (!apiKeyValue || apiKeyValue.length < 10) {
wcomLog(`Bitte gültigen API-Key im beschreibbaren Datenpunkt '${CONFIG.DP_API_KEY}' eintragen!`, 'error');
return;
}
const daysObj = await getStateAsync(CONFIG.DP_FORECAST_DAYS);
let forecastDays = daysObj && daysObj.val !== null ? Number(daysObj.val) : 7;
forecastDays = Math.max(1, Math.min(forecastDays, 16));
await wcomCheckDailyReset();
const allowFetch = await wcomCheckBudget(source);
if (!allowFetch) return;
const settings = await wcomGetSystemSettings();
if (!settings) return;
wcomLog(`Abruf gestartet für Lat: ${settings.lat}, Lon: ${settings.lon} (Trigger: ${source}, Tage: ${forecastDays})`, 'info');
const url: string = `${CONFIG.BASE_URL}/forecast/${settings.lat}/${settings.lon}`;
const options = { headers: { 'x-api-key': apiKeyValue, 'Accept-Language': settings.lang } };
const response = await wcomHttpGetAsync(url, options);
if (response && response.statusCode === 429) {
wcomLog('Das Limit von 100 API-Calls im Monat ist ausgeschöpft (HTTP 429).', 'error');
await setStateAsync(`${CONFIG.DP_PATH}.info.requests_month`, CONFIG.MONTHLY_LIMIT, true);
return;
}
if (response && response.statusCode !== 200) {
wcomLog(`API-Fehler: HTTP ${response.statusCode}`, 'error');
return;
}
await wcomUpdateUsageInfo();
let data: WetterComResponse;
try {
data = JSON.parse(response.data);
} catch (e) {
wcomLog('Konnte API-Antwort nicht parsen.', 'error');
return;
}
if (data && data.summary) {
await wcomProcessForecastData(data, settings.lang, forecastDays);
await wcomCleanupObsoleteDays(forecastDays);
}
} catch (e: any) {
wcomLog(`Script-Fehler: ${e.message}`, 'error');
} finally {
isFetching = false;
}
}
/**
* Schreibt das validierte JSON in die ioBroker-Datenpunkte mittels Promise-Batching.
* @param data Parsed JSON von Meteonomiqs.
* @param lang Verwendete Sprache.
* @param forecastDays Limitierung der Zukunfts-Tage aus den Einstellungen.
*/
async function wcomProcessForecastData(data: WetterComResponse, lang: string, forecastDays: number): Promise<void> {
await wcomEnsureSubStructure(CONFIG.DP_PATH, 'Wetter.com Forecast', 'device');
const maxDays: number = Math.min((data.summary ?? []).length, forecastDays);
let totalWrites = 0;
for (let i = 0; i < maxDays; i++) {
const dayWriteBuffer: Promise<any>[] = [];
const day: ForecastSummary = data.summary[i];
const dayPath: string = `${CONFIG.DP_PATH}.day_${i}`;
await wcomEnsureSubStructure(dayPath, `Tag ${i}`);
await wcomEnsureDayStates(dayPath, i);
const dayDateStrLocal = wcomFormatDate(day.date);
const iconName = `d_${day.weather?.state ?? 0}.svg`;
dayWriteBuffer.push(
setStateChangedAsync(`${dayPath}.date`, String(wcomFormatDate(day.date)), true),
setStateChangedAsync(`${dayPath}.day_name`, String(wcomGetDayName(day.date, lang)), true),
setStateChangedAsync(`${dayPath}.temp_max`, wcomExtractValue(day.temperature?.max), true),
setStateChangedAsync(`${dayPath}.temp_min`, wcomExtractValue(day.temperature?.min), true),
setStateChangedAsync(`${dayPath}.weather_text`, String(day.weather?.text || ''), true),
setStateChangedAsync(`${dayPath}.weather_icon`, `${CONFIG.ICON_BASE_URL}/${iconName}`, true),
setStateChangedAsync(`${dayPath}.prec_probability`, wcomExtractValue(day.prec?.probability), true),
setStateChangedAsync(`${dayPath}.prec_sum`, wcomExtractValue(day.prec?.sum), true),
setStateChangedAsync(`${dayPath}.wind_gusts`, wcomExtractValue(day.wind?.gusts), true),
setStateChangedAsync(`${dayPath}.wind_speed_max`, wcomExtractValue(day.wind?.max ?? day.wind?.avg), true),
setStateChangedAsync(`${dayPath}.sun_hours`, wcomExtractValue(day.sunHours), true),
setStateChangedAsync(`${dayPath}.clouds`, wcomExtractValue(day.clouds), true),
setStateChangedAsync(`${dayPath}.humidity`, wcomExtractValue(day.relativeHumidity), true)
);
if (CONFIG.ENABLE_SPACES && data.spaces && data.spaces[i]) {
const spacesPath: string = `${dayPath}.spaces`;
await wcomEnsureSubStructure(spacesPath, 'Tagesabschnitte');
const segments: (keyof ForecastSpace)[] = ['morning', 'afternoon', 'evening', 'night'];
for (const seg of segments) {
const sData = data.spaces[i][seg];
if (!sData) continue;
const sPath: string = `${spacesPath}.${seg}`;
await wcomEnsureSubStructure(sPath, seg);
await Promise.all([
wcomEnsureState(`${sPath}.temp`, 0, 'number', 'Temperatur', 'value.temperature', '°C'),
wcomEnsureState(`${sPath}.text`, '', 'string', 'Wetter', 'weather.state'),
wcomEnsureState(`${sPath}.prec_prob`, 0, 'number', 'Regenrisiko', 'value.precipitation.probability', '%'),
wcomEnsureState(`${sPath}.prec_sum`, 0, 'number', 'Regenmenge', 'value.precipitation', 'mm'),
wcomEnsureState(`${sPath}.wind_speed`, 0, 'number', 'Windgeschwindigkeit', 'value.speed.wind', 'km/h'),
wcomEnsureState(`${sPath}.wind_gusts`, 0, 'number', 'Windböen', 'value.speed.wind.gust', 'km/h'),
wcomEnsureState(`${sPath}.clouds`, 0, 'number', 'Bewölkung', 'value', '%'),
wcomEnsureState(`${sPath}.humidity`, 0, 'number', 'Relative Feuchte', 'value.humidity', '%')
]);
dayWriteBuffer.push(
setStateChangedAsync(`${sPath}.temp`, wcomExtractValue(sData.temperature), true),
setStateChangedAsync(`${sPath}.text`, String(sData.weather?.text || ''), true),
setStateChangedAsync(`${sPath}.prec_prob`, wcomExtractValue(sData.prec?.probability), true),
setStateChangedAsync(`${sPath}.prec_sum`, wcomExtractValue(sData.prec?.sum), true),
setStateChangedAsync(`${sPath}.wind_speed`, wcomExtractValue(sData.wind?.avg), true),
setStateChangedAsync(`${sPath}.wind_gusts`, wcomExtractValue(sData.wind?.gusts), true),
setStateChangedAsync(`${sPath}.clouds`, wcomExtractValue(sData.clouds), true),
setStateChangedAsync(`${sPath}.humidity`, wcomExtractValue(sData.relativeHumidity), true)
);
}
}
if (CONFIG.ENABLE_HOURLY && i <= 1 && data.hourly) {
const hourlyPath: string = `${dayPath}.hourly`;
await wcomEnsureSubStructure(hourlyPath, 'Stündlich');
const dayHours = (data.hourly ?? []).filter((h: ForecastHourly) => {
const hDateLocalStr = wcomFormatDate(h.from || h.date);
return hDateLocalStr === dayDateStrLocal;
});
for (const h of dayHours) {
const hourDate: Date = new Date(h.from || h.date);
const hourNum: number = hourDate.getHours();
const hourLabel: string = String(hourNum).padStart(2, '0');
const hPath: string = `${hourlyPath}.${hourLabel}`;
await wcomEnsureSubStructure(hPath, `${hourLabel}:00 Uhr`);
const hourIcon = (hourNum >= 18 || hourNum < 6) ? `n_${h.weather?.state ?? 0}.svg` : `d_${h.weather?.state ?? 0}.svg`;
await Promise.all([
wcomEnsureState(`${hPath}.time`, '', 'string', 'Uhrzeit', 'text'),
wcomEnsureState(`${hPath}.from`, '', 'string', 'Zeitstempel (UTC)', 'text'),
wcomEnsureState(`${hPath}.temp`, 0, 'number', 'Temperatur', 'value.temperature', '°C'),
wcomEnsureState(`${hPath}.windchill`, 0, 'number', 'Gefühlt', 'value.temperature', '°C'),
wcomEnsureState(`${hPath}.weather_text`, '', 'string', 'Wetter', 'weather.state'),
wcomEnsureState(`${hPath}.weather_icon`, '', 'string', 'Wetter Icon', 'weather.icon'),
wcomEnsureState(`${hPath}.prec_prob`, 0, 'number', 'Regenwahrscheinlichkeit', 'value.precipitation.probability', '%'),
wcomEnsureState(`${hPath}.prec_sum`, 0, 'number', 'Regenmenge', 'value.precipitation', 'mm'),
wcomEnsureState(`${hPath}.wind_speed`, 0, 'number', 'Windgeschwindigkeit', 'value.speed.wind', 'km/h'),
wcomEnsureState(`${hPath}.wind_dir`, '', 'string', 'Windrichtung', 'weather.direction'),
wcomEnsureState(`${hPath}.wind_gusts`, 0, 'number', 'Windböen', 'value.speed.wind.gust', 'km/h'),
wcomEnsureState(`${hPath}.humidity`, 0, 'number', 'Relative Feuchte', 'value.humidity', '%')
]);
dayWriteBuffer.push(
setStateChangedAsync(`${hPath}.time`, `${hourLabel}:00`, true),
setStateChangedAsync(`${hPath}.from`, String(h.from || h.date), true),
setStateChangedAsync(`${hPath}.temp`, wcomExtractValue(h.temperature), true),
setStateChangedAsync(`${hPath}.windchill`, wcomExtractValue(h.windchill), true),
setStateChangedAsync(`${hPath}.weather_text`, String(h.weather?.text || ''), true),
setStateChangedAsync(`${hPath}.weather_icon`, `${CONFIG.ICON_BASE_URL}/${hourIcon}`, true),
setStateChangedAsync(`${hPath}.prec_prob`, wcomExtractValue(h.prec?.probability), true),
setStateChangedAsync(`${hPath}.prec_sum`, wcomExtractValue(h.prec?.sum), true),
setStateChangedAsync(`${hPath}.wind_speed`, wcomExtractValue(h.wind?.avg), true),
setStateChangedAsync(`${hPath}.wind_dir`, String(h.wind?.direction || ''), true),
setStateChangedAsync(`${hPath}.wind_gusts`, wcomExtractValue(h.wind?.gusts), true),
setStateChangedAsync(`${hPath}.humidity`, wcomExtractValue(h.relativeHumidity), true)
);
}
}
totalWrites += dayWriteBuffer.length;
await Promise.all(dayWriteBuffer);
}
wcomLog(`Update von ${maxDays} Tagen abgeschlossen (${totalWrites} Werte prozessiert).`, 'info');
}
/**
* Löscht obsolete Tagesordner, falls die Vorhersage-Dauer reduziert wurde.
* @param forecastDays Aktuell konfigurierte Maximaldauer.
*/
async function wcomCleanupObsoleteDays(forecastDays: number): Promise<void> {
for (let i = forecastDays; i <= 25; i++) {
const path: string = `${CONFIG.DP_PATH}.day_${i}`;
if (existsObject(path)) {
await deleteObjectAsync(path, true);
}
}
}
/**
* Aktualisiert die Sync-Timestamps nach erfolgreichem HTTP 200.
*/
async function wcomUpdateUsageInfo(): Promise<void> {
const now: Date = new Date();
const timestamp: string = `${String(now.getDate()).padStart(2,'0')}.${String(now.getMonth()+1).padStart(2,'0')}.${now.getFullYear()} ${String(now.getHours()).padStart(2,'0')}:${String(now.getMinutes()).padStart(2,'0')}`;
await setStateAsync(`${CONFIG.DP_PATH}.info.last_sync`, String(timestamp), true);
await setStateAsync(`${CONFIG.DP_PATH}.info.last_sync_ts`, now.getTime(), true); // Neu für Cooldown
const countToday = await getStateAsync(`${CONFIG.DP_PATH}.info.requests_today`);
await setStateAsync(`${CONFIG.DP_PATH}.info.requests_today`, (countToday && countToday.val !== null ? Number(countToday.val) : 0) + 1, true);
const countMonth = await getStateAsync(`${CONFIG.DP_PATH}.info.requests_month`);
await setStateAsync(`${CONFIG.DP_PATH}.info.requests_month`, (countMonth && countMonth.val !== null ? Number(countMonth.val) : 0) + 1, true);
}
// --- ZEITSTEUERUNG & TRIGGER ---
schedule("0 0 1 * *", async () => {
const path = `${CONFIG.DP_PATH}.info.requests_month`;
if (existsState(path)) {
await setStateAsync(path, 0, true);
wcomLog('Monatszähler zurückgesetzt.', 'info');
}
});
// @KI_HINWEIS: Ersetzt die randomisierten Crons durch klar definierte, feste Zeiten im CONFIG.
schedule(CONFIG.UPDATE_CRON_MORNING, () => wcomFetchWeatherData('morning'));
schedule(CONFIG.UPDATE_CRON_AFTERNOON, () => wcomFetchWeatherData('afternoon'));
on({ id: CONFIG.DP_API_KEY, change: 'ne' }, (obj) => {
if (obj.state && typeof obj.state.val === 'string' && obj.state.val.trim().length >= 10) {
wcomLog('Änderung des API-Keys erkannt. Starte Test-Abruf...', 'info');
wcomFetchWeatherData('key_update');
}
});
on({ id: CONFIG.DP_FORECAST_DAYS, change: 'ne' }, (obj) => {
if (obj.state && obj.state.val !== null) {
wcomLog(`Änderung der Vorhersage-Tage auf ${obj.state.val} erkannt. Starte Aktualisierung & Bereinigung...`, 'info');
wcomFetchWeatherData('days_update');
}
});
on({ id: CONFIG.DP_FORCE_RESET, change: 'any', val: true }, async () => {
wcomLog('Manueller Reset ausgelöst. Setze Monatszähler auf 0.', 'warn');
await setStateAsync(`${CONFIG.DP_PATH}.info.requests_month`, 0, true);
await setStateAsync(CONFIG.DP_FORCE_RESET, false, true);
wcomFetchWeatherData('force_reset');
});
// Initialer Aufruf beim Skriptstart
wcomFetchWeatherData('start');
