# HTTP Request

Verarbeitung

HTTP Request

HTTP Request ver: 1

# Eingänge

ID	Kürzel	Name	Typ	Standard
`trigger`	`T`	trigger	BOOLEAN	`false`
`url`	`U`	url	STRING
`headers`	`H`	headers	STRING
`body`	`B`	body	STRING

# Ausgänge

ID	Kürzel	Name	Typ	Standard
`status`	`S`	status	NUMBER	`0`
`response`	`R`	response	STRING
`response_headers`	`RH`	response_headers	STRING
`success`	`OK`	success	BOOLEAN	`false`
`busy`	`BY`	busy	BOOLEAN	`false`

# Konfiguration

ID	Name	Typ	Standard	Beschreibung
`method`	method	ENUM	`0`	Details: Werte: GET, POST, PUT, DELETE, PATCH
`url`	url	STRING
`headers`	headers	STRING
`body`	body	STRING

# Zustand

ID	Name	Typ	Standard
`prev_trigger`	prev_trigger	BOOLEAN	`false`
`in_flight`	in_flight	BOOLEAN	`false`
`request_started`	request_started	NUMBER	`0`

# Quellcode

Volang-Quellcode anzeigen

fn apply_headers(client, headers) {
    if (headers == "") {
        return
    }

    pairs = str::split(headers, "|")
    while (str::split_has_next(pairs)) {
        pair = str::split_next(pairs)
        kv = str::split(pair, ":")
        key = str::split_next(kv)
        value = ""
        while (str::split_has_next(kv)) {
            if (value != "") {
                value = str::fmt("{}:{}", value, str::split_next(kv))
            } else {
                value = str::split_next(kv)
            }
        }
        http::set_header(client, key, value)
    }
}

fn serialize_headers(m) {
    keys = map::keys(m)
    if (array::len(keys) == 0) {
        return "{}"
    }

    result = ""
    i = 0
    while (i < array::len(keys)) {
        key = array::get_at(keys, i)
        val = map::get(m, key)
        result = str::fmt("""{}"{}":"{}",""", result, key, val)
        i = i + 1
    }
    return str::replace(str::fmt("{{}}", result), ",}", "}")
}

fn get_method_string(method_index) {
    if (method_index == 0) { return "GET" }
    if (method_index == 1) { return "POST" }
    if (method_index == 2) { return "PUT" }
    if (method_index == 3) { return "DELETE" }
    return "PATCH"
}

fn do_request() {
    state::set("in_flight", true)
    state::set("request_started", time::uptime())
    output::set("busy", true)

    url = input::get("url")
    if (url == "") {
        url = config::get("url")
    }

    headers = input::get("headers")
    if (headers == "") {
        headers = config::get("headers")
    }

    body = input::get("body")
    if (body == "") {
        body = config::get("body")
    }

    client = http::client()
    http::set_method(client, get_method_string(config::get("method")))
    apply_headers(client, headers)

    if (body != "") {
        http::set_body(client, body)
    }

    http::call(client, url)
}

extern fn http::on_response(status, body, headers) {
    output::set("status", status)
    output::set("response", body)
    output::set("success", status >= 200 and status < 300)

    output::set("response_headers", serialize_headers(headers))

    state::set("in_flight", false)
    output::set("busy", false)
}

channel = input::channel()
value = input::value()

if (channel == "trigger") {
    if (state::get("in_flight")) {
        request_started = state::get("request_started")
        if (time::uptime() - request_started > 10000) {
            state::set("in_flight", false)
            output::set("busy", false)
            output::set("success", false)
        }
    }

    prev_trigger = state::get("prev_trigger")

    if (value and !prev_trigger) {
        if (!state::get("in_flight")) {
            do_request()
        }
    }

    state::set("prev_trigger", value)
}