Alarmanlage und Anwesenheitssimulator mit OpenHAB

Group:Switch:OR(ON, OFF)	gWatchdog				
Switch						WatchdogManual			"Watchdog"	(fgPersist,gWatchdog,tgWatchdogEvents)		{ alexa="Switch" }
Switch						WatchdogNightshift					(fgPersist,gWatchdog)
DateTime					WatchdogTimestamp

Switch						TestDummy

/**
 * Watchdog / Alarm System
 */
const { rules, triggers, items, time, actions } = require("openhab");

// Cache für Timer, damit wir sie bei "Disarm" abbrechen können
const CACHE = cache.private; 
if (!CACHE.get("simTimers")) CACHE.put("simTimers", {});
if (!CACHE.get("alarmTimers")) CACHE.put("alarmTimers", []);

// Konstanten
const TELEGRAM_BOT = "telegram:telegramBot:home_Bot";
const CHAT_ID = -552188908; // Long in JS ist einfach Number
const SUNSET_START_ITEM = "LokaleSonnendaten_Set_Startzeit";
const CONFIRM_IF_ITEM = "Everywhere_Interface";

const roomTags = {
	Office: {
		startAfter: {
			delay: [0, 30], // Start: Sunset + 0-30min
		},
		endAfter: {	// Ausschalten planen: 23:00 + 0-120min
			h: 23,	// optional
			m: 0,	// optional
			delay: [0,120],
		},
	},
	
	Kitchen: {
		startAfter: {
			delay: [0, 180],
		},
		endAfter: {	// nach 45-120min
			delay: [45,120],
		},
	},
	
	Livingroom: {
		startAfter: {
			delay: [30, 90],
			actions:[
				["WzBackground_Helligkeit", 50],
				["WzTisch_Lightshow", "TV-Simulation"],
				["Echo_Wohnzimmer_Volume", 50],
				["Echo_Wohnzimmer_TextCommand", "echo spiele Robin Schulz"],
			],
		},
		endAfter: { // Ende: 22:30 + 0-120min
			h: 22,
			m: 30,
			delay: [0,120],
			actions:[
				["WzBackground_Helligkeit", 0],
				["WzTisch_Lightshow", 0],
				["Echo_Wohnzimmer_TextCommand", "echo stop"],
				["Echo_Wohnzimmer_Volume", 20],
			],
		},
	},
	
	Bedroom: {
		startAfter: {
			h: 21,	// optional
			m: 0,	// optional
			delay: [0, 150], // Start: Sunset + 0-30min
		},
		endAfter: {	// Ausschalten planen: 23:00 + 0-120min
			h: 23,	// optional
			m: 0,	// optional
			delay: [5,65],
		},
	},
};

// --- HELPER FUNCTIONS ---

/**
 * Fügt einen Timer zur Verwaltung hinzu
 */
function registerSimTimer(key, timerId) {
  const timers = CACHE.get("simTimers");
  // Falls schon einer existiert, vorher löschen (clean up)
  if (timers[key]) clearTimeout(timers[key]);
  timers[key] = timerId;
}

/**
 * Löscht alle Simulationstimer (bei Alarm-Ende)
 */
function clearAllSimTimers() {
  const timers = CACHE.get("simTimers");
  for (const key in timers) {
    clearTimeout(timers[key]);
  }
  CACHE.put("simTimers", {});
}

/**
 * Hilfsfunktion für zufällige Minuten (min bis max)
 */
function randomInt(min, max) {
    return Math.floor(Math.random() * (max - min + 1) + min);
}

/**
 * Berechnet die Verzögerung in Millisekunden bis zu einem ZDT
 */
function getDelayMillis(targetZDT) {
    const now = time.toZDT();
    let diff = targetZDT.toInstant().toEpochMilli() - now.toInstant().toEpochMilli();
    return Math.max(0, diff); // Keine negativen Delays
}

// --- Watchdog Leuchtsimulation ---
rules.JSRule({
  name: "Watchdog Leuchtsimulation",
  triggers: [
    triggers.ItemStateChangeTrigger("WatchdogManual", null, "ON"),
    triggers.ItemStateChangeTrigger("TestDummy", null, "ON"),
    triggers.GenericCronTrigger("0 0 6 ? * * *") // Täglich 6 Uhr Berechnung
  ],
  execute: (event) => {
    const watchdogManual = items.getItem("WatchdogManual");
    const testDummy = items.getItem("TestDummy");
	
	const triggeringItemName = event.itemName;
	
	var logPrefix = "Watchdog-Test";
	if(testDummy.state === "OFF"){
		logPrefix = "Watchdog";
	}
	
    // Prüfen ob aktiv
    if (watchdogManual.state === "ON" || testDummy.state === "ON") {
        console.info(logPrefix + ": Simulation gestartet (An)");

        // Optische Bestätigung
        if (testDummy.state === "OFF") {
            items.getItem(CONFIRM_IF_ITEM).sendCommand('{"effect": "blink"}');
        }

        // Sonnenuntergang holen
        const sunsetStr = items.getItem(SUNSET_START_ITEM).state;
        let sunset = time.toZDT(sunsetStr);
        const now = time.toZDT();

        // Falls Sonnenuntergang heute schon vorbei ist oder wir vor 6 Uhr sind, Logik prüfen.
        // Wenn sunset < now, starten Timer mit 0ms Delay sofort.
		
		for(const tag in roomTags){
			const fgPresSim = items.getItem("fgPresSim");
			const rooms = fgPresSim.members.filter(i => i.tags.includes(tag));
			
			rooms.forEach(room => {
				// Start: Sunset + n min
				let timeStart;
				const startConf = roomTags[tag]['startAfter'];
				if (typeof startConf['h'] !== 'undefined') {
					// Basis ist 'sunset', nicht 'now', um ungewollte Tagessprünge zu vermeiden
					timeStart = sunset.withHour(startConf['h']).withMinute(startConf['m'] || 0).plusMinutes(randomInt(startConf.delay[0], startConf.delay[1]));

					// if after midnight: +1 day
					if (timeStart.isBefore(sunset)) {
						timeStart = timeStart.plusDays(1);
					}
				} else {
					// Relative Endzeit basierend auf timeStart
					timeStart = sunset.plusMinutes( randomInt(startConf.delay[0], startConf.delay[1]) );
				}
				
				// ENDZEIT BERECHNEN (Vor dem Timeout!)
				let timeEnd;
				const endConf = roomTags[tag]['endAfter'];
				if (typeof endConf['h'] !== 'undefined') {
					// Basis ist 'sunset', nicht 'now', um ungewollte Tagessprünge zu vermeiden
					timeEnd = sunset.withHour(endConf['h']).withMinute(endConf['m'] || 0).plusMinutes(randomInt(endConf.delay[0], endConf.delay[1]));

					// if after midnight: +1 day
					if (timeEnd.isBefore(sunset)) {
						timeEnd = timeEnd.plusDays(1);
					}
				} else {
					// Relative Endzeit basierend auf timeStart
					const durationMinutes = randomInt(endConf.delay[0], endConf.delay[1]);
					timeEnd = timeStart.plusMinutes(durationMinutes);
				}
				// LOGIK-CHECK: Ist das geplante Ende bereits in der Vergangenheit?
				const now = time.toZDT();
				if (timeEnd.isBefore(now)) {
					console.info(`${logPrefix}: ${room.name} - Geplantes Ende (${timeEnd.toString()}) liegt in der Vergangenheit. Ãœberspringe Einschalten.`);
					return; // Bricht den Durchlauf für diesen Raum ab
				}
				
				// EINSCHALT-TIMER SETZEN
				const delayStart = getDelayMillis(timeStart); // Sollte bei negativen Werten 0 zurückgeben!
				
				const tStart = setTimeout(() => {
					const brightness = room.members.find(m => m.tags.includes("Brightness"));

					if (testDummy.state === "OFF") {
						if (typeof startConf['actions'] !== 'undefined') {
							for(const i in startConf['actions']){
								const action = startConf['actions'][i];
								items.getItem(action[0]).sendCommand(action[1])
							}
						}
						else if (brightness) {
							brightness.sendCommand(100);
						}
						else{
							console.warn(`${logPrefix}: Fehler - ${room.name} ohne Action und Brightness-Member-Item`);
							return;
						}
					}
					console.info(`${logPrefix}: ${room.name} An (bis ca. ${timeEnd.toLocalTime().toString()})`);

					// AUSSCHALT-TIMER SETZEN
					// Die verbleibende Zeit bis zum Ende wird erst jetzt final berechnet, 
					// damit Verzögerungen beim Ausführen des Start-Timers keine Rolle spielen.
					const delayEnd = getDelayMillis(timeEnd); 
					
					registerSimTimer('end_' + room.name, setTimeout(() => {
						if (testDummy.state === "OFF") {
							if (typeof endConf['actions'] !== 'undefined') {
								for(const i in endConf['actions']){
									const action = endConf['actions'][i];
									items.getItem(action[0]).sendCommand(action[1])
								}
							}
							else {
								brightness.sendCommand(0);
							}
						}
						console.info(`${logPrefix}: ${room.name} Aus`);
					}, delayEnd));

				}, delayStart);
				registerSimTimer('begin_' + room.name, tStart);
			});
		}
    }
  }
});


// --- Watchdog Aktivierungs-Verzögerung ---
rules.JSRule({
  name: "Watchdog changed Timestamp",
  triggers: [triggers.ItemStateChangeTrigger("gWatchdog", null, "ON")],
  execute: (event) => {
    // Speichert aktuellen Zeitpunkt als DateTime
    items.getItem("WatchdogTimestamp").postUpdate(time.toZDT().toString());
  }
});


// --- Fault and disturbance detection ---
rules.JSRule({
  name: "Fault and disturbance detection",
  triggers: [triggers.GenericCronTrigger("0 * * ? * * *")], // Jede Minute
  execute: (event) => {
    const now = time.toZDT();
    const fgFaultDetection = items.getItem("fgFaultDetection");
    const gWatchdog = items.getItem("gWatchdog");

    // 1. Check 5 Minuten (Device anpingen)
    // Wir suchen das erste Item, das > 5min nichts gesendet hat
    const faultItem5 = fgFaultDetection.members.find(i => {
        const lastUpdate = time.toZDT(i.state);
        return now.minusMinutes(5).isAfter(lastUpdate);
    });

    if (faultItem5) {
        // Gruppe finden
        const groupName = faultItem5.groupNames.find(g => g.startsWith("ig"));
        if (groupName) {
            const igGroup = items.getItem(groupName);
            const switchItem = igGroup.members.find(m => m.tags.includes("Switch") && m.tags.includes("Power"));
            
            if (switchItem) {
                // Refresh Trigger: Sendet den eigenen Status an sich selbst
                switchItem.sendCommand(switchItem.state);
                // console.info(`Watchdog Fault: Pinge ${switchItem.name}`);
            }
        }
    }

    // 2. Check 8 Minuten (Alarmierung)
    const faultItem8 = fgFaultDetection.members.find(i => {
        const lastUpdate = time.toZDT(i.state);
        return now.minusMinutes(8).isAfter(lastUpdate);
    });

    if (faultItem8 && gWatchdog.state !== "ON") {
        const telegram = actions.get("telegram", TELEGRAM_BOT);
        if (telegram) {
            telegram.sendTelegram(CHAT_ID, `Wartung nötig: ${faultItem8.name} hat sich länger als 8min nicht gemeldet!`);
        }
    }
  }
});


// --- End Watchdog Alarm ---
rules.JSRule({
  name: "End Watchdog Alarm",
  triggers: [
    triggers.ItemStateChangeTrigger("gWatchdog", null, "OFF"),
    triggers.ItemStateChangeTrigger("TestDummy", null, "OFF")
  ],
  execute: (event) => {
	const triggeringItem = items.getItem(event.itemName);
	
	var logPrefix = "Watchdog";
	if(triggeringItem.name == "TestDummy"){
		logPrefix = "Watchdog-Test";
	}
	
	console.info(logPrefix + ": System disarmed / Reset");
    
    // Lightshow Reset
    const tgLightshow = items.getItem("tgLightshow");
    tgLightshow.members
        .filter(i => i.tags.includes("Alarm") && i.tags.includes("DynamicScene"))
        .forEach(i => {
            if (i.state === "Alarm") i.sendCommand(67); // 67 scheint ein "Normal"-Code zu sein?
        });

    // Alarm Sounds Stop
    items.getItem("gAlexa_PlayAlarmSound").members
        .filter(i => i.tags.includes("Alarm"))
        .forEach(i => i.sendCommand(""));

    // Volume Reset
    items.getItem("gAlexa_Volume").members
        .filter(i => i.tags.includes("Alarm"))
        .forEach(i => i.sendCommand(20));

    // Simulation Timer löschen
    clearAllSimTimers();
    
    // Aktive Alarm-Sequenz Timer löschen (falls man mitten im Alarm unscharf schaltet)
    const alarmTimers = CACHE.get("alarmTimers");
    alarmTimers.forEach(id => clearTimeout(id));
    CACHE.put("alarmTimers", []);
  }
});


// --- Watchdog Alarm ---
rules.JSRule({
  name: "Watchdog Alarm Execution",
  triggers: [
    triggers.GroupStateChangeTrigger("gCamAlert"),
    triggers.GroupStateChangeTrigger("fgIntrusion")
  ],
  execute: (event) => {
    const triggeringItemName = event.itemName;
    const testDummy = items.getItem("TestDummy");
    const gWatchdog = items.getItem("gWatchdog");
    const watchdogTimestamp = items.getItem("WatchdogTimestamp");

    if (testDummy.state === "ON") {
        console.info("Watchdog-Test: ALARM TRIGGERED by " + triggeringItemName);
    }

    // Grace Period Check: Ist Alarm "Scharf" und älter als 5 Minuten?
    const armedTime = time.toZDT(watchdogTimestamp.state);
    const isSystemReady = gWatchdog.state === "ON" && time.toZDT().minusMinutes(5).isAfter(armedTime);

    // Trigger Logik prüfen (gCamAlert immer, fgIntrusion nur wenn neuer Status "höher"/schlimmer ist??)
    // Vereinfachung: Wir reagieren auf Change. Im Original: (newState > previousState) für Intrusion.
    // Da wir JS Event Object nutzen, können wir newState prüfen.
    
    let isValidTrigger = false;
    if (triggeringItemName === "gCamAlert") isValidTrigger = true;
    else {
        // Bei fgIntrusion gehen wir davon aus, dass ON/OPEN der Alarmzustand ist
        const newState = event.newState;
        if (newState === "ON" || newState === "OPEN") isValidTrigger = true;
    }

    if (isSystemReady && isValidTrigger) {
        
        console.warn("Watchdog: ECHTER ALARM AUSGELÖST!");
        items.getItem("Office_Lightshow").sendCommand("Alarm");

        // Alarm-Sequenz starten (Verschachtelte Timeouts)
        // Wir speichern die Timer IDs in einer Liste, um sie bei "End Watchdog" abbrechen zu können.
        const alarmTimers = [];

        // 1. Verzögerung 60 Sekunden (Voralarm / Entry Delay)
        const t1 = setTimeout(() => {
            // Nochmals prüfen, ob Alarm noch an ist (vielleicht wurde er in den 60s deaktiviert)
            if (items.getItem("gWatchdog").state === "ON") {
                
                // Licht-Alarm
                items.getItem("tgLightshow").members
                    .filter(i => i.tags.includes("Alarm") && i.tags.includes("DynamicScene"))
                    .forEach(i => {
                        i.sendCommand(67); // Reset?
                        i.sendCommand("Alarm");
                    });

                // Alexa Sequenz starten
                const gAlexaPlay = items.getItem("gAlexa_PlayAlarmSound").members.filter(i => i.tags.includes("Alarm"));
                const gAlexaVol = items.getItem("gAlexa_Volume").members.filter(i => i.tags.includes("Alarm"));
                const gAlexaTTS = items.getItem("gAlexa_TTS").members.filter(i => i.tags.includes("Alarm"));

                // Sirene an
                gAlexaPlay.forEach(i => i.sendCommand("ECHO:system_alerts_rhythmic_02"));

                // 2. Sirene für 10 Sekunden
                const t2 = setTimeout(() => {
                    // Sirene Stop
                    gAlexaPlay.forEach(i => i.sendCommand(""));

                    if (items.getItem("gWatchdog").state === "ON") {
                        // Lautstärke hoch
                        gAlexaVol.forEach(i => i.sendCommand(80));
                        // Ansage
                        gAlexaTTS.forEach(i => i.sendCommand("Eindringling entdeckt! Notruf wurde abgesetzt. Polizei ist unterwegs."));

                        // 3. Warten auf Ansage (4s), dann Sirene wieder an
                        const t3 = setTimeout(() => {
                            if (items.getItem("gWatchdog").state === "ON") {
                                gAlexaPlay.forEach(i => i.sendCommand("ECHO:system_alerts_rhythmic_02"));
                            }
                        }, 4000);
                        alarmTimers.push(t3);
                    }
                }, 10000);
                alarmTimers.push(t2);

                // Telegram Meldung
                const fgIntrusion = items.getItem("fgIntrusion");
                fgIntrusion.members.forEach(item => {
                    // Prüfen welches Item ausgelöst hat (Im Original logic: if item.state == OFF ?? Das macht wenig Sinn bei Alarm. 
                    // Vermutlich war gemeint: Sende Info über alle Sensoren.
                    // Wir senden einfach den Auslöser.
                    if (item.name === triggeringItemName || item.state.toString() === "OPEN" || item.state.toString() === "ON") {
                        const groupLabels = item.groupNames.map(gn => items.getItem(gn).label).join(" ");
                        const telegram = actions.get("telegram", TELEGRAM_BOT);
                        if(telegram) {
                            telegram.sendTelegram(CHAT_ID, `Eindringling-Alarm wurde ausgelöst!: ${groupLabels} - ${item.label}`);
                        }
                    }
                });
            }
        }, 60000);
        
        alarmTimers.push(t1);
        CACHE.put("alarmTimers", alarmTimers);
    }
  }
});


// --- Start/End Nightshift ---
rules.JSRule({
  name: "Start Nightshift",
  triggers: [
    triggers.ItemStateChangeTrigger("KalenderWatchdog_CurrentEventPresence", null, "ON"),
    triggers.ItemStateChangeTrigger("SmartButton1_DimmerSwitch")
  ],
  execute: (event) => {
    const calendarWecken = items.getItem("KalenderWecken_CurrentEventPresence");
    
    // Logik aus Original: Wenn Wecken-Kalender aus ist
    if (calendarWecken.state === "OFF") {
        items.getItem("WatchdogNightshift").sendCommand("ON");
    }
  }
});

rules.JSRule({
  name: "End Nightshift",
  triggers: [triggers.ItemStateChangeTrigger("KalenderWatchdog_CurrentEventPresence", null, "OFF")],
  execute: (event) => {
    items.getItem("WatchdogNightshift").sendCommand("OFF");
  }
});