Alerty SMS i głosowe dla Ignition SCADA

				
					import system

LOGGER = system.util.getLogger("SMSEagle")
CONFIG\_PATH = "\[default]SMSEagle/Config"


def getConfig():
    """Czyta konfiguracje bramki z tagow."""
    paths = \[
        "%s/gatewayUrl" % CONFIG\_PATH,
        "%s/accessToken" % CONFIG\_PATH,
        "%s/voiceId" % CONFIG\_PATH,
        "%s/callDuration" % CONFIG\_PATH,
        "%s/verifySsl" % CONFIG\_PATH,
    ]
    v = system.tag.readBlocking(paths)
    return {
        "url": str(v\[0].value).rstrip("/"),
        "token": str(v\[1].value),
        "voiceId": int(v\[2].value or 2),
        "duration": int(v\[3].value or 20),
        "verifySsl": bool(v\[4].value),
    }


def \_normalize(recipients):
    """Akceptuje string lub liste. Formaty odbiorcy:
    "+48111222333" numer, "15:c" kontakt, "12:g" grupa z Phonebook.
    """
    if recipients is None:
        return \[]
    if isinstance(recipients, basestring):
        return \[r.strip() for r in recipients.split(",") if r.strip()]
    return \[str(r).strip() for r in recipients if str(r).strip()]


def \_post(endpoint, payload, kind):
    """Wysyla zadanie do APIv2 i loguje wynik."""
    cfg = getConfig()
    if not cfg\["url"] or not cfg\["token"]:
        LOGGER.error("Brak konfiguracji: gatewayUrl lub accessToken")
        return False

    client = system.net.httpClient(
        timeout=10000,
        bypass\_cert\_validation=not cfg\["verifySsl"]
    )
    headers = {"access-token": cfg\["token"],
               "Content-Type": "application/json"}

    try:
        r = client.post(cfg\["url"] + endpoint, headers=headers, data=payload)
    except Exception, e:
        LOGGER.error("%s: blad polaczenia: %s" % (kind, str(e)))
        return False

    if r.good:
        LOGGER.info("%s wyslany, HTTP %s" % (kind, r.statusCode))
        return True

    LOGGER.error("%s odrzucony, HTTP %s: %s" % (kind, r.statusCode, r.text))
    return False


def sendSms(recipients, text, priority=None):
    to = \_normalize(recipients)
    if not to:
        LOGGER.warn("sendSms: pusta lista odbiorcow")
        return False
    payload = {"to": to, "text": text}
    if priority is not None:
        payload\["priority"] = int(priority)
    return \_post("/api/v2/messages/sms", payload, "SMS")


def ringCall(recipients, duration=None):
    to = \_normalize(recipients)
    if not to:
        return False
    cfg = getConfig()
    payload = {"to": to, "duration": int(duration or cfg\["duration"])}
    return \_post("/api/v2/calls/ring", payload, "Ring call")


def ttsAdvancedCall(recipients, text, voiceId=None, duration=None):
    to = \_normalize(recipients)
    if not to:
        return False
    cfg = getConfig()
    payload = {
        "to": to,
        "text": text,
        "voice\_id": int(voiceId or cfg\["voiceId"]),
        "duration": int(duration or cfg\["duration"]),
    }
    return \_post("/api/v2/calls/tts\_advanced", payload, "TTS Advanced call")


def formatAlarm(event):
    return "%s | %s | prio %s" % (
        event.get("displayPath") or event.get("source"),
        event.get("label"),
        event.priority
    )


def notifyAlarm(event, recipients=None, mode="SMS",
                voiceId=None, duration=None):
    """Punkt wejscia dla bloku Script w Notification Pipeline."""
    if recipients is None:
        recipients = system.tag.readBlocking(
            \["%s/defaultRecipients" % CONFIG\_PATH])\[0].value

    text = formatAlarm(event)
    mode = (mode or "SMS").upper()
    ok = True

    if mode in ("SMS", "SMS\_AND\_RING", "SMS\_AND\_TTS"):
        ok = sendSms(recipients, text) and ok
    if mode in ("RING", "SMS\_AND\_RING"):
        ok = ringCall(recipients, duration) and ok
    if mode in ("TTS", "SMS\_AND\_TTS"):
        ok = ttsAdvancedCall(recipients, text, voiceId, duration) and ok

    return ok


def testConnection():
    """Diagnostyka. Wywolaj z konsoli skryptowej Designera."""
    cfg = getConfig()
    if not cfg\["url"]:
        return {"ok": False, "status": 0, "message": "Nie ustawiono gatewayUrl"}

    client = system.net.httpClient(
        timeout=10000,
        bypass\_cert\_validation=not cfg\["verifySsl"]
    )
    headers = {"access-token": cfg\["token"]}

    try:
        r = client.get(cfg\["url"] + "/api/v2/modem/status", headers=headers)
    except Exception, e:
        return {"ok": False, "status": 0, "message": str(e)}

    if r.good:
        return {"ok": True, "status": r.statusCode,
                "message": "Polaczenie poprawne"}

    hints = {
        401: "Nieprawidlowy lub wygasly token API",
        403: "Uzytkownik API nie ma wymaganych uprawnien",
        404: "Sprawdz adres bramki i wersje firmware (wymagane APIv2)",
    }
    return {"ok": False, "status": r.statusCode,
            "message": hints.get(r.statusCode, r.text)}