Document how to parse JSON POSTed to the ESP

[probonopd]

How do we parse JSON POSTed to the ESP, i.e., what is the ESPAsyncWebServer equivalent of esp8266/Arduino#1321 (comment)

StaticJsonBuffer<200> jsonBuffer;
JsonObject& root = jsonBuffer.parseObject(server.arg("plain"));

?

The following educated guess, jsonBuffer.parseObject(request->getParam("plain", true)->value());, seems not to work for me:

  server.on("/api/printer/command", HTTP_POST, [](AsyncWebServerRequest * request) {
    const size_t bufferSize = JSON_OBJECT_SIZE(1) + 250;
    DynamicJsonBuffer jsonBuffer(bufferSize);
    JsonObject& root = jsonBuffer.parseObject(request->getParam("plain", true)->value());
    const char* command = root["command"];
    request->send(204);
  });

Is this documented somewhere? If not, please document it.

[jeremypoulter]

For what it is worth, I have got this to work, have a look here

[probonopd]

So you are saying it should be JsonObject& root = jsonBuffer.parseObject(request->getParam("body", true)->value());? Where do you have that information from?

[jeremypoulter]

I think so (was a while ago when I last looked at this). IIRC I just cut and paste the content of the not found handler from the example. This outputs loads of useful info about the request.

[probonopd]

Thank you. Can't seem to get it to work yet, though...

[stelgenhof]

Tried it and works perfectly!

[probonopd]

Apparently there is more than meets the eye. request->getParam("body", true)->value() does not work for me since apparently there is no body to begin with...

If I send the following request curl -H "Content-Type: application/json" -X POST -d '{"command": "Hello"}' http://192.168.0.22/ to the ESP, which looks like this:

POST / HTTP/1.1
User-Agent: curl/7.37.0
Host: 127.0.0.1
Accept: */*
Content-Length: 20

{"command": "Hello"}

then the sketch returns No body?!:

#include <ESP8266WiFi.h>

#include <ESPAsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include <ESPAsyncWiFiManager.h> // https://github.com/alanswx/ESPAsyncWiFiManager/

#include "AsyncJson.h"
#include "ArduinoJson.h"

AsyncWebServer server(80);
DNSServer dns;

void setup() {

  Serial.begin(115200);

  AsyncWiFiManager wifiManager(&server, &dns);
  wifiManager.autoConnect("AutoConnectAP");

  server.on("/", HTTP_POST, [](AsyncWebServerRequest * request) {
    // Count number of params
    int params = request->params(); // 0
    Serial.println(params);
    if (request->hasParam("body", true)) { // This is important, otherwise the sketch will crash if there is no body
      request->send(200, "text/plain", request->getParam("body", true)->value());
    } else {
      Serial.println("No body?!");
      request->send(200, "text/plain", "No body?!\n");
    }
  });

  server.begin();
}

void loop() {
}

[probonopd]

It seems like others were having similar issues too but this never was clearly documented:
#123

[stelgenhof]

@probonopd I can retrieve the JSON body if I use it this way: ->value().c_str().
But probably it is better to use the onRequestBody callback.

[probonopd]

That segfaults for me:

#include <ESP8266WiFi.h>

#include <ESPAsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include <ESPAsyncWiFiManager.h> // https://github.com/alanswx/ESPAsyncWiFiManager/

#include "AsyncJson.h"
#include "ArduinoJson.h"

AsyncWebServer server(80);
DNSServer dns;

void setup() {

  Serial.begin(115200);

  AsyncWiFiManager wifiManager(&server, &dns);
  wifiManager.autoConnect("AutoConnectAP");

  server.on("/", HTTP_POST, [](AsyncWebServerRequest * request) {
      request->send(200, "text/plain", request->getParam("body", true)->value().c_str());
  });

  server.begin();
}

void loop() {
}

But probably it is better to use the onRequestBody callback.

How would we do that?

[probonopd]

This seems to be working, thanks @sochs for the hint:

#include <ESP8266WiFi.h>

#include <ESPAsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include <ESPAsyncWiFiManager.h> // https://github.com/alanswx/ESPAsyncWiFiManager/

#include "AsyncJson.h"
#include "ArduinoJson.h"

AsyncWebServer server(80);
DNSServer dns;

void setup() {

  Serial.begin(115200);

  AsyncWiFiManager wifiManager(&server, &dns);
  wifiManager.autoConnect("AutoConnectAP");

  server.onRequestBody([](AsyncWebServerRequest * request, uint8_t *data, size_t len, size_t index, size_t total) {
    Serial.println("Running");
    if (request->url() == "/test") {
      DynamicJsonBuffer jsonBuffer;
      JsonObject& root = jsonBuffer.parseObject((const char*)data);
      if (root.success()) {
        if (root.containsKey("command")) {
          Serial.println(root["command"].asString()); // Hello
        }
      }
      request->send(200, "text/plain", "end");
    }
  });
  server.begin();
}

void loop() {
}

[stelgenhof]

Going to try that! Thanks @probonopd

[stelgenhof]

@probonopd It works great! Thanks for the example.

[devyte]

"Use the source Luke!"

I'm leaving this here in case anyone else is looking for this answer.

Using the onRequestBody() callback doesn't work for me, and even if it did, it is a single callback for all endpoints. the body param also didn't work for me, the received request never received a body parameter.

After looking through the source, I found that there are 3 versions of the server.on() method for setting callbacks. The first is the simple one, as seen in most examples:
server.on(endpoint, HTTP_POST, callback)
The second is a flavor used for file upload. It takes two callbacks, the second of which handles file chunks:
server.on(endpoint, HTTP_POST, callback, onFileUploadCB)
And drum roll... the third flavor takes 3 callbacks:
server.on(endpoint, HTTP_POST, callback, onFileUploadCB, onBodyCB)
The first two are same as in the previous case, and the third is an onBody handler, called when the body is received.
This can show how these work:

  server.on("/test", HTTP_POST, 
      [](AsyncWebServerRequest *request)
      {
        Serial.println("1");
      },
      [](AsyncWebServerRequest *request, const String& filename, size_t index, uint8_t *data, size_t len, bool final)
      {
        Serial.println("2");
      },
      [](AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total)
      {
        Serial.println("3");
        Serial.println(String("data=") + (char*)data);
      });

From what I gather, when posting with a body, the 2nd callback isn't used.
In theory, the 3rd callback can be called several times, because the body can be received in chunks. For me, it gets called only once for bodies up to about 1.5KB. Didn't test with bigger bodies.

This doesn't seem documented, but it works for me, and the semantics look correct.
Anyways, I hope this helps somebody.