qml_http_request.hpp

#pragma once
#include <ossia/network/context.hpp>
#include <ossia/network/http/http_client_request.hpp>
 
#include <ossia-qt/protocols/utils.hpp>
#include <ossia-qt/qml_protocols.hpp>
 
#include <verdigris>
 
namespace ossia::qt
{
 
struct qml_protocols_http_answer;
struct qml_protocols_http_error;
using request_type = ossia::net::http_client_request<
    qml_protocols_http_answer, qml_protocols_http_error>;
 
struct qml_protocols_http_answer
{
  static constexpr int reserve_expect = 65536 * 8;
  QPointer<qml_protocols> self{};
  QJSValue v;
 
  // The legacy callback takes the body alone: every final response is
  // delivered to it, as dropping non-2xx ones would leave the script no way to
  // observe that anything happened at all. The status goes to the log.
  void operator()(auto& req, int status, std::string_view str)
  {
    if(status < 200 || status >= 300)
      ossia::logger().error("HTTP Error: status code {}", status);
 
    ossia::qt::run_async(self.get(), [self = self, v = v, s = QString::fromUtf8(str)] {
      if(self)
        if(v.isCallable())
          v.call({s});
    });
  }
};
 
// No error channel towards the script: a failure is reported to the log, never
// to the success callback with a made-up body.
struct qml_protocols_http_error
{
  void operator()(auto& req, std::string_view msg)
  {
    ossia::logger().error("HTTP request failed: {}", msg);
  }
};
 
// --- New fetch() types (full HTTP client) ---
 
struct qml_protocols_fetch_answer;
struct qml_protocols_fetch_error;
using fetch_request_type = ossia::net::http_client_request<
    qml_protocols_fetch_answer, qml_protocols_fetch_error>;
 
struct qml_protocols_fetch_answer
{
  static constexpr int reserve_expect = 65536 * 8;
  QPointer<qml_protocols> self{};
  QJSValue onResponse;
  void operator()(auto& req, int status, std::string_view str)
  {
    ossia::qt::run_async(
        self.get(),
        [self = self, v = onResponse, status, s = QString::fromUtf8(str)] {
      if(self)
        if(v.isCallable())
        {
          auto engine = qjsEngine(self.get());
          if(engine)
            v.call({QJSValue(status), engine->toScriptValue(s)});
        }
    });
  }
};
 
struct qml_protocols_fetch_error
{
  QPointer<qml_protocols> self{};
  QJSValue onError;
  void operator()(auto& req, std::string_view msg)
  {
    ossia::qt::run_async(
        self.get(), [self = self, v = onError, m = QString::fromUtf8(msg)] {
      if(self)
        if(v.isCallable())
          v.call({m});
    });
  }
};
 
}