Jahresrückblick 2025 – unser neuer Blogbeitrag ist online! ✨

[sigi234]

@oliverio sagte in FF-Einsätze OÖ auswerten:

@sigi234
dann exportiere es einfach so

Blockly_Feuerwehr.txt

[sigi234]

@negalein sagte in FF-Einsätze OÖ auswerten:

@sigi234 sagte in FF-Einsätze OÖ auswerten:

jetzt kommt eine Fehlermeldung.

Ja, weil die Seite komplett umgebaut wurde.
Damals war es RSS und jetzt irgend ein anderes komisches Ding.

Ach ja jetzt erinnere ich mich wieder....

ALT:
http://intranet.ooelfv.at/webext2/rss/json_laufend.txt

NEU:
https://cf-einsaetze.ooelfv.at/webext2/rss/webext2_laufend.xml

[Negalein]

@oliverio sagte in FF-Einsätze OÖ auswerten:

Für telegram und Alexa.
Ich verwende beides nicht.
Hast du da bisherigen code?

das ist der JS-Code eines Blockly mit Telegram und Alexa

schedule("0 17 * * *", async function () {
  if (getState("trashschedule.0.type.altpapier.daysLeft").val == 1) {
    sendTo("telegram", "send", {
        text: 'Morgen wird Altpapier abgeholt!'
    });
    sendTo("enigma2.0", "send", {message: 'Morgen wird Altpapier abgeholt!', timeout: 30, msgType: 1});
    setState("alexa2.0.Echo-Devices.G2A0XL07022603EU.Commands.speak"/*speak*/, '50;Morgen wird Altpapier abgeholt!');
    setStateDelayed("alexa2.0.Echo-Devices.G090XG0692741RRD.Commands.speak"/*speak*/, '50;Morgen wird Altpapier abgeholt!', 10000, false);
    setStateDelayed("alexa2.0.Echo-Devices.G090U5099045059V.Commands.speak"/*speak*/, '50;Morgen wird Altpapier abgeholt!', 20000, false);
  }
  if (getState("trashschedule.0.type.gelbersack.daysLeft").val == 1) {
    sendTo("telegram", "send", {
        text: 'Morgen wird der gelbe Sack abgeholt!'
    });
    sendTo("enigma2.0", "send", {message: 'Morgen wird der gelbe Sack abgeholt!', timeout: 30, msgType: 1});
    setState("alexa2.0.Echo-Devices.G090U5099045059V.Commands.speak"/*speak*/, '50;Morgen wird der gelbe Sack abgeholt!');
    setStateDelayed("alexa2.0.Echo-Devices.G090XG0692741RRD.Commands.speak"/*speak*/, '50;Morgen wird der gelbe Sack abgeholt!', 10000, false);
    setStateDelayed("alexa2.0.Echo-Devices.G2A0XL07022603EU.Commands.speak"/*speak*/, '50;Morgen wird der gelbe Sack abgeholt!', 20000, false);
  }
  if (getState("trashschedule.0.type.restabfall.daysLeft").val == 1) {
    sendTo("telegram", "send", {
        text: 'Morgen wird der Müll abgeholt!'
    });
    sendTo("enigma2.0", "send", {message: 'Morgen wird der Müll abgeholt!', timeout: 30, msgType: 1});
    setStateDelayed("alexa2.0.Echo-Devices.G090U5099045059V.Commands.speak"/*speak*/, '50;Morgen wird der Müll abgeholt!', 30000, false);
    setStateDelayed("alexa2.0.Echo-Devices.G090XG0692741RRD.Commands.speak"/*speak*/, '50;Morgen wird der Müll abgeholt!', 40000, false);
    setStateDelayed("alexa2.0.Echo-Devices.G2A0XL07022603EU.Commands.speak"/*speak*/, '50;Morgen wird der Müll abgeholt!', 50000, false);
  }
});

[OliverIO]

@negalein

wir bewegen uns nun im ungetesteten bereich, da ich das selbst nur bedingt testen kann
dazu kamen nun die funktionen
prepareMessages(einsaetze,kurz,alle)
diese prüft und bereitet die übergebenen einsätze auf, so das da ein test entsteht. das format habe ich dem blockly entnommen (bzw dem javascript code aus dem blockly heraus)
prepareMessages hat 3 parameter
einsaetze = die einsaetze die geprüft und aufbereitet werden sollen
kurz= true/false, die message wird kurz oder mit weiteren angaben lang generiert (genauso wie im blockly)
alle=wenn true, dann wird nicht mehr geprüft, ob dazu schon mal eine meldung ausgegeben wurde
die prüfung wird nur innerhalb der laufzeit des skripts gemerkt. sobald das skript neu gestartet wird, ist das gedächtnis weg. wenn gewünscht, könnte man das in einen datenpunkt verlegen, so das das auch einen neustart überlebt
sendTelegram(text,user)
der angegebene text wird an den angegebenen user an den telegram adapter gesendet
sendEMail(text, to, subject)
der angegebene text wird an die angegebene to-adresse mit subject als betreff an den email adapter gesendet
sendAlexa(text, lautstaerke)
der angegebene text wird mit lautstaerke in die entsprechenden datenpunkte geschrieben. die datenpunkte sind direkt in der funktion definiert.

im vergleich zur vorgängerversion habe ich den aufruf nun in schedule angepasst, so das auch alle 30 sekunden aufgerufen wird

var xml2js = require('xml2js');
//var fetch = require('node-fetch');
const useragent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
let einsaetzeGesendet = [];

async function getData() {
    const response = await fetch("https://cf-einsaetze.ooelfv.at/webext2/rss/webext2_laufend.xml", {
        "headers": {
            "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
            "accept-language": "de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7",
            "cache-control": "no-cache",
            "pragma": "no-cache",
            "sec-ch-ua": "\"Not_A Brand\";v=\"8\", \"Chromium\";v=\"120\", \"Google Chrome\";v=\"120\"",
            "sec-ch-ua-mobile": "?0",
            "sec-ch-ua-platform": "\"Windows\"",
            "sec-fetch-dest": "document",
            "sec-fetch-mode": "navigate",
            "sec-fetch-site": "none",
            "sec-fetch-user": "?1",
            "upgrade-insecure-requests": "1",
            "User-Agent": useragent
        },
        "referrerPolicy": "strict-origin-when-cross-origin",
        "body": null,
        "method": "GET"
    });
    let text = await response.text();
    return text;
}
async function xml2json(xml) {
    return new Promise(function (resolve, reject) {
        var parser = new xml2js.Parser(
            {
                explicitArray: false
            }
        );
        parser.parseString(xml, function (err, result) {
            if (err) {
                reject(err);
            } else {
                resolve(result);
            }
        })
        // xml2js.parseString(xml, function (err, result) {
        // });
    })
    // var parser = new xml2js.Parser();
    // parser.parseString(xml, function (err, result) {
    //     console.dir(result);
    // });
}
function normalizeData(obj) {
    let a = 1;
    let einsaetze = [];
    for (let i = 0; i < obj.length; i++) {
        let einsatz = obj[i];
        let einsatzNeu = {
            id: einsatz.$.id,
            startzeit: einsatz.startzeit,
            status: einsatz.status,
            alarmstufe: einsatz.alarmstufe,
            einsatzart: einsatz.einsatzart,
            einsatzorg: einsatz.einsatzorg,
            einsatztyp: einsatz.einsatztyp._,
            einsatzsubtyp: einsatz.einsatzsubtyp._,
            alarmtext: einsatz.alarmtext,
            earea: einsatz.adresse.earea,
            bezirk_name: einsatz.bezirk._,
            bezirk_id: einsatz.bezirk.$.id,
            lng: einsatz.lng,
            lat: einsatz.lat,
            einheiten: []
        };
        if (Array.isArray(einsatz.einheiten.einheit) == false) {
            einsatz.einheiten.einheit = [einsatz.einheiten.einheit];
        }
        for (let j = 0; j < einsatz.einheiten.einheit.length; j++) {
            let einheit = einsatz.einheiten.einheit[j];
            einsatzNeu.einheiten.push({
                id: einheit.$.id,
                bezeichnung: einheit._
            })
        }
        einsaetze.push(einsatzNeu);
    }
    return einsaetze;
}
function filterEinheiten(einsaetze, einheiten) {
    if (!einheiten) throw Error("Einheiten ids müssen angegeben werden");
    return einsaetze.filter(einsatz => einheiten.some(id => einsatz.einheiten.some(einheit => einheit.id == id)));
}
function filterBezirk(einsaetze, bezirk) {
    if (!bezirk) throw Error("bezirkid muss angegeben werden");
    return einsaetze.filter(einsatz => einsatz.bezirk_id == bezirk);
}
function toHtml(einsaetze) {
    let rows = "";
    einsaetze.forEach(einsatz => {
        let einheiten = einsatz.einheiten.map(einheit => einheit.bezeichnung).join("<br>");
        rows += `
            <tr>
                <td>${einsatz.alarmstufe}</td>
                <td>${einsatz.alarmtext}</td>
                <td>${einheiten}</td>
                <td>${einsatz.earea}</td>
                <td>${einsatz.lat}</td>
                <td>${einsatz.lng}</td>
            </tr>
        `
    })
    let html = `
    <table>
      <tr>
        <th>Alarmstufe</th>
        <th>Alarmtext</th>
        <th>Einheiten</th>
        <th>EAREA</th>
        <th>lat</th>
        <th>lng</th>
      </tr>
      ${rows}
    </table>
    `;

    return html;
}
function prepareMessages(einsaetze, kurz, alle) {
    let messages = [];
    einsaetze.map(einsatz => {
        if (!einsaetzeGesendet.includes(einsatz.id) || alle) {
            if (kurz) {
                messages.push(['Achtung; Feuerwehreinsatz in ', einsatz.earea, '; ', 'Alarmstufe ', einsatz.alarmstufe, '; ', einsatz.einsatzsubtyp, ';'].join(''));
            } else {
                messages.push(['Achtung; Feuerwehreinsatz in ', einsatz.earea, '; ', 'Alarmstufe ', einsatz.alarmstufe, '; ', einsatz.einsatzsubtyp, ';', einsatz.startzeit, ';', einsatz.bezirk_name, '; Anzahl Feuerwehren ', einsatz.einheiten.length, ';'].join(''));
            }
            einsaetzeGesendet.push(einsatz.id);
        }
    })
    if (messages.length == 0) messages.push("Keine Meldung.");
    return messages.join("\n");

}
function sendTelegram(text, user) {
    sendTo("telegram.0", "send", {
        text: text,
        user: user,
    });
}
function sendEMail(text, to, subject) {
    sendTo("email.0", "send", {
         text: text,
         to: to,
         subject: subject
      });
}
function sendAlexa(text, lautstaerke) {
    setState('alexa2.0.Echo-Devices.G0922H0724770WBW.Commands.speak-volume', lautstaerke);
    setState('alexa2.0.Echo-Devices.G0922H0724770WBW.Commands.speak', text);
}

async function main() {
    let xml = await getData()
    let json = await xml2json(xml);
    let einsaetze = normalizeData(json.webext2.einsaetze.einsatz);
    let einsaetze_einheiten = filterEinheiten(einsaetze, [410321, 410327]);
    let einsaetze_bezirk = filterBezirk(einsaetze, 10);
    let html1 = toHtml(einsaetze_einheiten);
    let html2 = toHtml(einsaetze_bezirk);
    let html3 = toHtml(einsaetze);
    let messages = prepareMessages(einsaetze, true, false);
    //messages = prepareMessages(einsaetze, true, false);
    let nachtruhe=compareTimeBetween("01:00", "06:00");
    if (!nachtruhe) sendAlexa(messages, 60);
    sendTelegram(messages, "Heiko");
    sendEMail(messages, "xxx@gmx.at", "Neuer Feuerwehreinsatz");
    console.log(html1);
    console.log(html2);
    console.log(html3);
    //setState("0_userdata.0.testFolder.a", html3);
}
schedule('*/30 * * * * *',main)

[Negalein]

@oliverio

bin gerade erst dazu gekommen

function prepareMessages(einsaetze, kurz, alle) {
    let messages = [];
    einsaetze.map(einsatz => {
        if (!einsaetzeGesendet.includes(einsatz.id) || alle) {
            if (kurz) {
                messages.push(['Achtung; Feuerwehreinsatz in ', einsatz.earea, '; ', 'Alarmstufe ', einsatz.alarmstufe, '; ', einsatz.einsatzsubtyp, ';'].join(''));
            } else {
                messages.push(['Achtung; Feuerwehreinsatz in ', einsatz.earea, '; ', 'Alarmstufe ', einsatz.alarmstufe, '; ', einsatz.einsatzsubtyp, ';', einsatz.startzeit, ';', einsatz.bezirk_name, '; Anzahl Feuerwehren ', einsatz.einheiten.length, ';'].join(''));
            }
            einsaetzeGesendet.push(einsatz.id);
        }
    })
    if (messages.length == 0) messages.push("Keine Meldung.");
    return messages.join("\n");
 
}
function sendTelegram(text, user) {
    sendTo("telegram.0", "send", {
        text: text,
        user: user,
    });
}
function sendEMail(text, to, subject) {
    sendTo("email.0", "send", {
         text: text,
         to: to,
         subject: subject
      });
}
function sendAlexa(text, lautstaerke) {
    setState('alexa2.0.Echo-Devices.G0922H0724770WBW.Commands.speak-volume', lautstaerke);
    setState('alexa2.0.Echo-Devices.G0922H0724770WBW.Commands.speak', text);
}
 
async function main() {
    let xml = await getData()
    let json = await xml2json(xml);
    let einsaetze = normalizeData(json.webext2.einsaetze.einsatz);
    let einsaetze_einheiten = filterEinheiten(einsaetze, [410321, 410327]);
    let einsaetze_bezirk = filterBezirk(einsaetze, 10);
    let html1 = toHtml(einsaetze_einheiten);
    let html2 = toHtml(einsaetze_bezirk);
    let html3 = toHtml(einsaetze);
    let messages = prepareMessages(einsaetze, true, false);
    //messages = prepareMessages(einsaetze, true, false);
    let nachtruhe=compareTimeBetween("01:00", "06:00");
    if (!nachtruhe) sendAlexa(messages, 60);
    sendTelegram(messages, "");
    sendEMail(messages, "hias@gmx.at", "Neuer Feuerwehreinsatz");
    console.log(html1);
    console.log(html2);
    console.log(html3);
    //setState("0_userdata.0.testFolder.a", html3);
	setState("0_userdata.0.FF-Einsatz.Einsatz1", html1);
	setState("0_userdata.0.FF-Einsatz.Einsatz2", html2);
}
schedule('*/30 * * * * *',main)

So schaut der konfigurierbare Teil jetzt aus.

if (!nachtruhe) sendAlexa(messages, 60); ---> das ! bedeutet "nicht nachtruhe"? 60 ist die Lautstärke. Und messages holt er sich von function prepareMessages?

sendTelegram(messages, ""); & sendEMail(messages ---> selbiges mit messages

function prepareMessages(einsaetze, kurz, alle) ---> konfigurier ich hier let messages = []; in [] ob kurz oder alle? Das mit einsaetze check ich nicht ganz.
Da hier nur von kurz oder elsegeredet wird.

            if (kurz) {
                messages.push(['Achtung; Feuerwehreinsatz in ', einsatz.earea, '; ', 'Alarmstufe ', einsatz.alarmstufe, '; ', einsatz.einsatzsubtyp, ';'].join(''));
            } else {
                messages.push(['Achtung; Feuerwehreinsatz in ', einsatz.earea, '; ', 'Alarmstufe ', einsatz.alarmstufe, '; ', einsatz.einsatzsubtyp, ';', einsatz.startzeit, ';', einsatz.bezirk_name, '; Anzahl Feuerwehren ', einsatz.einheiten.length, ';'].join(''));

die prüfung wird nur innerhalb der laufzeit des skripts gemerkt. sobald das skript neu gestartet wird, ist das gedächtnis weg.

heißt das, dass alle 30 Sekunden die Meldung kommt? Oder wie ist das gemeint?

[OliverIO]

@negalein sagte in FF-Einsätze OÖ auswerten:

@oliverio

bin gerade erst dazu gekommen

So schaut der konfigurierbare Teil jetzt aus.

if (!nachtruhe) sendAlexa(messages, 60); ---> das ! bedeutet "nicht nachtruhe"?

ja genau, sprachlich passt das nicht ganz, aber so war es in blockly definiert

60 ist die Lautstärke.

ja 60 ist die lauttärke, so war es im blockly voreingestellt

Und messages holt er sich von function prepareMessages?

so ungefährt. prepareMessages nimmt alle einsaetze als parameter und gibt diese dann als messages aus. für das testen habe ich die variable einsaetze genommen, da weder für einheiten noch für bezirk gerade einsätze waren. wahlweise kannst du da aber auch die variablen einsaetze_einheiten oder einsaetze_bezirk übergeben. dann werden nur diese aufbereitet. der funktion ist es egal.

sendTelegram(messages, ""); & sendEMail(messages ---> selbiges mit messages

nimmt die messages und übergibt sie an die entsprechenden adapter, die sich dann um den eigentlichen versandt kümmern.

function prepareMessages(einsaetze, kurz, alle) ---> konfigurier ich hier let messages = []; in [] ob kurz oder alle? Das mit einsaetze check ich nicht ganz.

nein, wie gesagt die einsaetze kommen von den vorhergehenden funktionen und prepareMessages bereitet die auf, so das da ein gescheiter text rauskommt.
die parameter kurz und alle steuern die verarbeitung.
kurz=true sorgt dafür, das da nur kurze messages rauskommen, also manche angaben werden weggelassen
alle=true sorgt dafür, das egal was bereits vorher mal übermittelt wurde, alle neu versendet werden. alle=false sorgt dafür, das jeder einsatz nur einmal nach messages übernommen wird.
prepareMessages(einsaetze, true, true) -> alle aus einsaetze werden in der kurzform ausgegeben
prepareMessages(einsaetze, false, false) -> es werden nur einsaetze, die noch nie gemeldet wurden in der langform ausgegeben
prepareMessages(einsaetze, true, false) -> einsaetze die noch nie gemeldet wurden werden in der kurzform ausgegeben
prepareMessages(einsaetze, false, true) -> alle einsaetze werden werden in der langform ausgegeben

Da hier nur von kurz oder elsegeredet wird.

das sind die beiden formen, wie die messages aufbereitet werden. bei kurz=true halt nur kurz
und bei kurz=false in der langform. wenn du dir die zeilen mit push anschaust, stehen da unterschiedliche anzahl von parameter drin.

            if (kurz) {
                messages.push(['Achtung; Feuerwehreinsatz in ', einsatz.earea, '; ', 'Alarmstufe ', einsatz.alarmstufe, '; ', einsatz.einsatzsubtyp, ';'].join(''));
            } else {
                messages.push(['Achtung; Feuerwehreinsatz in ', einsatz.earea, '; ', 'Alarmstufe ', einsatz.alarmstufe, '; ', einsatz.einsatzsubtyp, ';', einsatz.startzeit, ';', einsatz.bezirk_name, '; Anzahl Feuerwehren ', einsatz.einheiten.length, ';'].join(''));

die prüfung wird nur innerhalb der laufzeit des skripts gemerkt. sobald das skript neu gestartet wird, ist das gedächtnis weg.

heißt das, dass alle 30 Sekunden die Meldung kommt? Oder wie ist das gemeint?

nein. du startest das skript. schedule sorgt dafür, das alle 30 sekunden die funktion main aufgerufen wird, also abruf der daten, aufbereitung, filtern, ausgabe der messages.
solange das skript läuft, weiß das skript welche einsätze bereits in messages ausgegeben wurde, so das nicht alle 30 sekunden die gleichen einsätze immer und immer wieder wiederholt werden (sofern bei perepareMessages der parameter alle =false ist, siehe oben)
wenn du das skript stoppst und dann wieder startest ist die variable wieder leer und es werden beim nächsten start wieder alle einsätze ausgegeben.

[Negalein]

@oliverio

ich bekomm diese Fehler beim Start des Scripts

javascript.0	15:54:00.005	error	script.js.Feuerwehr.FF-Alarm: ReferenceError: fetch is not defined
javascript.0	15:54:00.006	error	at getData (script.js.Feuerwehr.FF-Alarm:8:22)
javascript.0	15:54:00.006	error	at Object.main (script.js.Feuerwehr.FF-Alarm:163:21)

das Script

var xml2js = require('xml2js');
//var fetch = require('node-fetch');
const useragent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
let einsaetzeGesendet = [];
 
async function getData() {
    const response = await fetch("https://cf-einsaetze.ooelfv.at/webext2/rss/webext2_laufend.xml", {
        "headers": {
            "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
            "accept-language": "de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7",
            "cache-control": "no-cache",
            "pragma": "no-cache",
            "sec-ch-ua": "\"Not_A Brand\";v=\"8\", \"Chromium\";v=\"120\", \"Google Chrome\";v=\"120\"",
            "sec-ch-ua-mobile": "?0",
            "sec-ch-ua-platform": "\"Windows\"",
            "sec-fetch-dest": "document",
            "sec-fetch-mode": "navigate",
            "sec-fetch-site": "none",
            "sec-fetch-user": "?1",
            "upgrade-insecure-requests": "1",
            "User-Agent": useragent
        },
        "referrerPolicy": "strict-origin-when-cross-origin",
        "body": null,
        "method": "GET"
    });
    let text = await response.text();
    return text;
}
async function xml2json(xml) {
    return new Promise(function (resolve, reject) {
        var parser = new xml2js.Parser(
            {
                explicitArray: false
            }
        );
        parser.parseString(xml, function (err, result) {
            if (err) {
                reject(err);
            } else {
                resolve(result);
            }
        })
        // xml2js.parseString(xml, function (err, result) {
        // });
    })
    // var parser = new xml2js.Parser();
    // parser.parseString(xml, function (err, result) {
    //     console.dir(result);
    // });
}
function normalizeData(obj) {
    let a = 1;
    let einsaetze = [];
    for (let i = 0; i < obj.length; i++) {
        let einsatz = obj[i];
        let einsatzNeu = {
            id: einsatz.$.id,
            startzeit: einsatz.startzeit,
            status: einsatz.status,
            alarmstufe: einsatz.alarmstufe,
            einsatzart: einsatz.einsatzart,
            einsatzorg: einsatz.einsatzorg,
            einsatztyp: einsatz.einsatztyp._,
            einsatzsubtyp: einsatz.einsatzsubtyp._,
            alarmtext: einsatz.alarmtext,
            earea: einsatz.adresse.earea,
            bezirk_name: einsatz.bezirk._,
            bezirk_id: einsatz.bezirk.$.id,
            lng: einsatz.lng,
            lat: einsatz.lat,
            einheiten: []
        };
        if (Array.isArray(einsatz.einheiten.einheit) == false) {
            einsatz.einheiten.einheit = [einsatz.einheiten.einheit];
        }
        for (let j = 0; j < einsatz.einheiten.einheit.length; j++) {
            let einheit = einsatz.einheiten.einheit[j];
            einsatzNeu.einheiten.push({
                id: einheit.$.id,
                bezeichnung: einheit._
            })
        }
        einsaetze.push(einsatzNeu);
    }
    return einsaetze;
}
function filterEinheiten(einsaetze, einheiten) {
    if (!einheiten) throw Error("Einheiten ids müssen angegeben werden");
    return einsaetze.filter(einsatz => einheiten.some(id => einsatz.einheiten.some(einheit => einheit.id == id)));
}
function filterBezirk(einsaetze, bezirk) {
    if (!bezirk) throw Error("bezirkid muss angegeben werden");
    return einsaetze.filter(einsatz => einsatz.bezirk_id == bezirk);
}
function toHtml(einsaetze) {
    let rows = "";
    einsaetze.forEach(einsatz => {
        let einheiten = einsatz.einheiten.map(einheit => einheit.bezeichnung).join("<br>");
        rows += `
            <tr>
                <td>${einsatz.alarmstufe}</td>
                <td>${einsatz.alarmtext}</td>
                <td>${einheiten}</td>
                <td>${einsatz.earea}</td>
                <td>${einsatz.lat}</td>
                <td>${einsatz.lng}</td>
            </tr>
        `
    })
    let html = `
    <table>
      <tr>
        <th>Alarmstufe</th>
        <th>Alarmtext</th>
        <th>Einheiten</th>
        <th>EAREA</th>
        <th>lat</th>
        <th>lng</th>
      </tr>
      ${rows}
    </table>
    `;
 
    return html;
}
function prepareMessages(einsaetze, kurz, alle) {
    let messages = [];
    einsaetze.map(einsatz => {
        if (!einsaetzeGesendet.includes(einsatz.id) || alle) {
            if (kurz) {
                messages.push(['Achtung; Feuerwehreinsatz in ', einsatz.earea, '; ', 'Alarmstufe ', einsatz.alarmstufe, '; ', einsatz.einsatzsubtyp, ';'].join(''));
            } else {
                messages.push(['Achtung; Feuerwehreinsatz in ', einsatz.earea, '; ', 'Alarmstufe ', einsatz.alarmstufe, '; ', einsatz.einsatzsubtyp, ';', einsatz.startzeit, ';', einsatz.bezirk_name, '; Anzahl Feuerwehren ', einsatz.einheiten.length, ';'].join(''));
            }
            einsaetzeGesendet.push(einsatz.id);
        }
    })
    if (messages.length == 0) messages.push("Keine Meldung.");
    return messages.join("\n");
 
}
function sendTelegram(text, user) {
    sendTo("telegram.0", "send", {
        text: text,
        user: user,
    });
}
function sendEMail(text, to, subject) {
    sendTo("email.0", "send", {
         text: text,
         to: to,
         subject: subject
      });
}
function sendAlexa(text, lautstaerke) {
    setState('alexa2.0.Echo-Devices.xxxxxxxxxxxx.Commands.speak-volume', lautstaerke);
    setState('alexa2.0.Echo-Devices.xxxxxxxxxx.Commands.speak', text);
}
 
async function main() {
    let xml = await getData()
    let json = await xml2json(xml);
    let einsaetze = normalizeData(json.webext2.einsaetze.einsatz);
    let einsaetze_einheiten = filterEinheiten(einsaetze, [410321, 410327]);
    let einsaetze_bezirk = filterBezirk(einsaetze, 2);
    let html1 = toHtml(einsaetze_einheiten);
    let html2 = toHtml(einsaetze_bezirk);
    let html3 = toHtml(einsaetze);
    let messages = prepareMessages(einsaetze, false, false);
    //messages = prepareMessages(einsaetze, true, false);
    let nachtruhe=compareTimeBetween("01:00", "06:00");
    if (!nachtruhe) sendAlexa(messages, 60);
    sendTelegram(messages, "");
    sendEMail(messages, "christian@xxxxxxxxx.at", "Neuer Feuerwehreinsatz");
    console.log(html1);
    console.log(html2);
    console.log(html3);
    //setState("0_userdata.0.testFolder.a", html3);
	setState("0_userdata.0.FF-Einsatz.Bezirk", html2);	
}
schedule('*/30 * * * * *',main)

[OliverIO]

@negalein said in FF-Einsätze OÖ auswerten:

//var fetch = require('node-fetch');

ändern in

var fetch = require('node-fetch');

[sigi234]

@oliverio
Wie bekomme ich nur Meldungen von einen bestimmten Bezirk?

[sigi234]

@oliverio sagte in FF-Einsätze OÖ auswerten:

@negalein said in FF-Einsätze OÖ auswerten:

//var fetch = require('node-fetch');

ändern in

var fetch = require('node-fetch');

Das habe ich bei mir nicht auskommentiert, muss ich das?

[Negalein]

@oliverio

jetzt kommt das

javascript.0 2024-09-10 18:21:00.096	error	at processTicksAndRejections (node:internal/process/task_queues:95:5)
javascript.0 2024-09-10 18:21:00.096	error	at Object.main (script.js.Feuerwehr.FF-Alarm:173:19)
javascript.0 2024-09-10 18:21:00.096	error	script.js.Feuerwehr.FF-Alarm: ReferenceError: compareTimeBetween is not defined

[OliverIO]

@negalein

tausche bitte Zeile 172 gegen

    let nachtruhe=compareTime("01:00", "06:00","between");

[sigi234]

@negalein

Die Seite (XML) soll alle 30 Sekunden abgefragt werden

Ist das nicht zu kurz, das wird den Betreiber nicht gefallen .Oder ist das egal?

Kann ich das wo ändern?

[OliverIO]

@negalein said in FF-Einsätze OÖ auswerten:

Die Seite (XML) soll alle 30 Sekunden abgefragt werden, ob bestimmte Feuerwehren (bei mir 2) aktuell einen Einsatz haben.
<einheit id="410321">
<einheit id="410327">

hm, das hast du selbst angegeben.
du kannst es auch gerne verlängern.

[Negalein]

@oliverio sagte in FF-Einsätze OÖ auswerten:

let nachtruhe=compareTime("01:00", "06:00","between");

Merci, funktioniert .... fast

Telegram und Alexa läuft.

Aber nach der Ansage kommt alle 30 Sek. keine Meldung

[OliverIO]

@oliverio said in FF-Einsätze OÖ auswerten:

prepareMessages(einsaetze,kurz,alle)
diese prüft und bereitet die übergebenen einsätze auf, so das da ein test entsteht. das format habe ich dem blockly entnommen (bzw dem javascript code aus dem blockly heraus)
prepareMessages hat 3 parameter
einsaetze = die einsaetze die geprüft und aufbereitet werden sollen
kurz= true/false, die message wird kurz oder mit weiteren angaben lang generiert (genauso wie im blockly)
> alle=wenn true, dann wird nicht mehr geprüft, ob dazu schon mal eine meldung ausgegeben wurde
die prüfung wird nur innerhalb der laufzeit des skripts gemerkt. sobald das skript neu gestartet wird, ist das gedächtnis weg. wenn gewünscht, könnte man das in einen datenpunkt verlegen, so das das auch einen neustart überlebt

ja, prepareMessages prüft, ob ein Einsatz schon einmal gemeldet wurde und widerholt diesen dann nicht mehr. evtl sollte es heißen "keine neuen Meldungen"
wenn du es immer wiederholt haben möchtest, dann musst du bei prepareMessages den 3.Parameter auf true setzen

[OliverIO]

@sigi234 said in FF-Einsätze OÖ auswerten:

Das habe ich bei mir nicht auskommentiert, muss ich das?

nein. in älteren nodes gibt es den befehl fetch nicht standardmäßig. erst in neuern.
die bibliothek füllt diese lücke für ältere nodes.

bei mir in vscode verwende ich schon eine neuere version bei der fetch automatisch enthalten ist

[OliverIO]

@sigi234 said in FF-Einsätze OÖ auswerten:

@oliverio
Wie bekomme ich nur Meldungen von einen bestimmten Bezirk?

der ablauf ist ja so:

abrufen der daten
umwandeln von xml nach json
normalisieren der daten.
bis hierin muss man die reihenfolge zwingend einhalten.

danach liegen alle einsätze in einer variable vor.
mit
let einsaetze_einheiten = filterEinheiten(einsaetze, [410321, 410327]);
let einsaetze_bezirk = filterBezirk(einsaetze, 10);

filterst du alle einsätze auf die angegebenen sortierkriterien.
das ergebnis wird dann in der angegebenen variable gespeichert.
welche du davon dann weiterverwendest, bleibt dir überlassen

[Negalein]

@oliverio sagte in FF-Einsätze OÖ auswerten:

ja, prepareMessages prüft, ob ein Einsatz schon einmal gemeldet wurde und widerholt diesen dann nicht mehr. evtl sollte es heißen "keine neuen Meldungen"
wenn du es immer wiederholt haben möchtest, dann musst du bei prepareMessages den 3.Parameter auf true setzen

Ich habs so let messages = prepareMessages(einsaetze, false, false);

Er schickt die Meldung raus, und nach der Meldung kommt immer keine Meldung.

Kann man das so machen, dass die Meldung kommt, diese als gesendet markiert/gemerckt wird, aber dann nicht immer keine Meldung kommt.
Sondern erst bei einer neuen Meldung wieder an Telegram, usw. nur die neue Meldung geschickt wird.

[OliverIO]

@negalein

ja
sendMessages wird nur dann aufgerufen wenn in messages was drin steht
hab ich jetzt nicht getestet, aber müsste so gehen

in der funktion prepareMessages die folgende Zeile entfernen

    if (messages.length == 0) messages.push("Keine Meldung.");

und in der Funktion main() bei sendTelegram vorne noch ergänzen.

if (messages) sendTelegram(messages, "");

messages ist dann leer, wenn keine (neuen) Einsätze gefunden werden
und sendTelegram wird nur aufgerufen wenn es neue Einsätze gibt

Wenn du die Änderungen gemacht hast, poste bitte nochmal das ganze Skript,
das ich einen neuen Aufstzpunkt für evtl weitere Änderungen habe