void handleRoot(HTTPRequest * req, HTTPResponse * res);

void handleSVG(HTTPRequest * req, HTTPResponse * res);

void handleQueryDemo(HTTPRequest * req, HTTPResponse * res);

void handlePathParam(HTTPRequest * req, HTTPResponse * res);

void handle404(HTTPRequest * req, HTTPResponse * res);

void setup() {

// For every resource available on the server, we need to create a ResourceNode

// The ResourceNode links URL and HTTP method to a handler function

ResourceNode * nodeRoot = new ResourceNode("/", "GET", &handleRoot);

ResourceNode * nodeSVG = new ResourceNode("/images/awesome.svg", "GET", &handleSVG);

ResourceNode * nodeQueryDemo = new ResourceNode("/queryparams", "GET", &handleQueryDemo);

ResourceNode * node404 = new ResourceNode("", "GET", &handle404);

// Path parameters

// If you want (for example) to return a specific instance of an object type by its ID

// you can use URLs like /led/1, led/2, ... - And you do not need to register one Resource

// Node per ID, but you can use wildcards in the route definition. The following route

// has two wildcards, and will match for example to /urlparam/foo/bar, where "foo" and "bar"

// are accessible parameters in the handler function.

// Note: The wildcards can only be used between slashes at the moment (so /urlparam* would

// not work).

ResourceNode * nodeURLParam = new ResourceNode("/urlparam/*/*", "GET", &handlePathParam);

// Add the root node to the server

secureServer.registerNode(nodeRoot);

// Add the SVG image

secureServer.registerNode(nodeSVG);

// Query parameter demo

secureServer.registerNode(nodeQueryDemo);

// Add the path parameter

// Note: The order of nodes may become important here. If you have one node for "/led" (e.g. list of LEDs)

// and one node for /led/* (LED details), you should register the non-parameterized version first. The server

// follows a first-match policy. If you would register the details node first, a call to /led/ will be targetted

res->println("<!DOCTYPE html>");

res->println("<html>");

res->println("<head><title>Hello World!</title></head>");

res->println("<style>.info{font-style:italic}</style>");

res->println("<body>");

res->println("<h1>Query Parameters</h1>");

res->println("<p class=\"info\">The parameters after the question mark in your URL.</p>");

// Show a form to select a color to colorize the faces

// We pass the selection as get parameter "shades" to this very same page,

// Depending on the selection we show the images in a specific color shade

// Default is dark gray.

int r = 63, g = 63, b = 63;

std::string paramVal;

if (params->getQueryParameter(paramName, paramVal)) {

if (paramVal == "red" || paramVal == "magenta" || paramVal == "yellow" || paramVal == "rainbow") {

r = 128 + random(0, 128);

}

res->print("\" alt=\"Awesome!\" />");

}

res->println("<p>You'll find another demo <a href=\"/queryparams?a=42&b&c=13&a=hello\">here</a>.</p>");

// Link to the path parameter demo

res->println("<h1>Path Parameters</h1>");

res->println("<p class=\"info\">The parameters derived from placeholders in your path, like /foo/bar.</p>");

res->println("<p>You'll find the demo <a href=\"/urlparam/foo/bar\">here</a>.</p>");

res->println("</body>");

res->println("</html>");

}

void handleSVG(HTTPRequest * req, HTTPResponse * res) {

// Get access to the parameters

// Get request parameter (like awesome.svg?color=ff0000) and validate it

std::string colorParamName = "color";

// Check that the parameter is set and retrieve it.

// The getQueryParameter function will modify the second parameter, but only if the query

// parameter is set.

std::string requestColor;

if (params->getQueryParameter(colorParamName, requestColor)) {

// Check for correct length

if (requestColor.length()==6) {

bool colorOk = true;

res->print("</svg>");

}

void handleQueryDemo(HTTPRequest * req, HTTPResponse * res) {

// A word of warning: In this example, we use the query parameters and directly print

// them into the HTML output. We do this to simplify the demo. NEVER do this in a

// real application, as it allows cross-site-scripting.

res->setHeader("Content-Type", "text/html");

res->println("<!DOCTYPE html>");

res->println("<html>");

res->println("<head>");

res->println("<title>Query Parameter Demo</title>");

res->println("</head>");

res->println("<body>");

res->println("<p>The following query paramters have been set:</p>");

// Start a table to display the parameters

res->println("<table style=\"border:1px solid black collapse;\">");

res->println("<tr><th>Key</th><th>Value</th></tr>");

// Iterate over the parameters. For more information, read about the C++ standard template library,

// especially about vectors and iterators.

ResourceParameters *params = req->getParams();

for(auto it = params->beginQueryParameters(); it != params->endQueryParameters(); ++it) {

res->print("<tr><td>");

// The iterator yields std::pairs of std::strings. The first value contains the parameter key

res->printStd((*it).first);

res->print("</td><td>");

// and the second value contains the parameter value

res->printStd((*it).second);

res->println("</td></tr>");

}

res->println("</table>");

// You can retrieve the total parameter count from the parameters instance:

res->print("<p>There are a total of ");

res->print(params->getQueryParameterCount());

res->print(" parameters, with ");

res->print(params->getQueryParameterCount(true));

res->println(" unique keys.</p>");

res->println("<p>Go <a href=\"/\">back to main page</a>.</p>");

res->println("</body>");

res->println("</html>");

}

void handlePathParam(HTTPRequest * req, HTTPResponse * res) {

// Get access to the parameters

ResourceParameters * params = req->getParams();

// The url pattern is: /urlparam/*/*

// This will make the content for the first parameter available on index 0,

// and the second wildcard as index 1.

// getPathParameter will - like getQueryParameter - write the value to the second parameter,

// and return true, if the index is valid. Otherwise it returns false and leaves the second

// parameter as it is.

std::string parameter1, parameter2;

// Print the first parameter value

if (params->getPathParameter(0, parameter1)) {

res->print("Parameter 1: ");

res->printStd(parameter1);

}

res->println();

// Print the second parameter value

if (params->getPathParameter(1, parameter2)) {

res->print("Parameter 2: ");

res->printStd(parameter2);

}

res->println("\n\nChange the parameters in the URL to see how they get parsed!");

}

#include <HTTPResponse.hpp>

#include <util.hpp>

using namespace httpsserver;

SSLCert * getCertificate();

void handleSPIFFS(HTTPRequest * req, HTTPResponse * res);

void handleGetUptime(HTTPRequest * req, HTTPResponse * res);

void handleGetEvents(HTTPRequest * req, HTTPResponse * res);

void handlePostEvent(HTTPRequest * req, HTTPResponse * res);

void handleDeleteEvent(HTTPRequest * req, HTTPResponse * res);

#define MAX_EVENTS 20

struct {

int state;

} events[MAX_EVENTS];

HTTPSServer * secureServer;

void handleDeleteEvent(HTTPRequest * req, HTTPResponse * res) {

// Access the parameter from the URL. See Parameters example for more details on this

ResourceParameters * params = req->getParams();

size_t eid = std::atoi(params->getPathParameter(0).c_str());

if (eid < MAX_EVENTS) {

// Set the inactive flag

// Iterate over the validators and run them

std::vector<HTTPValidator*> * validators = node->getValidators();

for(std::vector<HTTPValidator*>::iterator validator = validators->begin(); valid && validator != validators->end(); ++validator) {

std::string param;

if (params->getPathParameter((*validator)->_idx, param)) {

valid = ((*validator)->_validatorFunction)(param);

} else {

valid = false;

}

}

if (valid) {

_validators = new std::vector<HTTPValidator*>();

// Count the parameters

_pathParamCount = 0;

size_t idx = 0;

while((idx = path.find("/*", idx)) != std::string::npos) {

_pathParamCount+=1;

// If we don't do this, the same index will be found again... and again... and again...

idx+=1;

};

// Check if there are parameters

if (_pathParamCount > 0) {

// If there are parameters, store their indices

_pathParamIdx = new size_t[_pathParamCount];

for(int i = 0; i < _pathParamCount; i++) {

_pathParamIdx[i] = path.find("/*", i==0 ? 0 : _pathParamIdx[i-1])+1;

}

} else {

_pathParamIdx = NULL;

}

}

HTTPNode::~HTTPNode() {

if (_pathParamIdx != NULL) {

delete[] _pathParamIdx;

}

// Delete validator references

delete _validators;

}

bool HTTPNode::hasPathParameter() {

return _pathParamCount > 0;

}

size_t HTTPNode::getParamIdx(uint8_t idx) {

if (idx<_pathParamCount) {

return _pathParamIdx[idx];

} else {

return -1;

}

}

size_t HTTPNode::getPathParamCount() {

return _pathParamCount;

}

void HTTPNode::addPathParamValidator(size_t paramIdx, const HTTPValidationFunction * validator) {

_validators->push_back(new HTTPValidator(paramIdx, validator));

}