Router.h

Go to the documentation of this file.

 
#ifndef ROUTER_HPP
#define ROUTER_HPP
#pragma once
 
#include <vector>
#include <string>
#include <unordered_map>
#include <functional>
#include <FreeRTOS.h>
#include <semphr.h>
#include "http/RouteTypes.h" // for RouteMatch
#include "http/HttpRequest.h"
#include "http/HttpResponse.h"
#include "http/HttpFileserver.h" // for HttpFileserver
 
 
using RouteHandler = std::function<void(HttpRequest &, HttpResponse &, const RouteMatch &)>;
 
using Middleware = std::function<bool(HttpRequest &, HttpResponse &, const RouteMatch &)>;
 
class Router
{
public:
    Router();
    Router(const Router&) = delete;
    Router& operator=(const Router&) = delete;
 
    void use(Middleware middleware);
 
    void addRoute(const std::string &method,
                  const std::string &path,
                  RouteHandler handler,
                  std::vector<Middleware> middleware = {});
 
    void addCatchAllGetRoute(RouteHandler handler, std::vector<Middleware> middleware = {});
         
    // Optional 2-argument route handler overload for convenience
    inline void addRoute(Router& router,
            const std::string& method,
            const std::string& path,
            std::function<void(HttpRequest&, HttpResponse&)> simpleHandler) {
            router.addRoute(method, path,
            [=](HttpRequest& req, HttpResponse& res, const RouteMatch&) {
            simpleHandler(req, res);
        });
    }              
 
    bool handleRequest(HttpRequest &req, HttpResponse &res);
 
#ifdef PICO_HTTP_ENABLE_JWT
    bool handle_auth_req(HttpRequest &req, HttpResponse &res, const std::vector<std::string> &params);
#endif
 
    bool extractAuthorizationToken(const std::string &auth_header);
 
    std::string getAuthorizationToken(const HttpRequest &req);
 
#ifdef PICO_HTTP_ENABLE_JWT
    bool isAuthorizedForRoute(const Route &route, HttpRequest &req, HttpResponse &res);
#else
    bool isAuthorizedForRoute(const Route &route, HttpRequest &req, HttpResponse &res) { return true; }
#endif
    void printRoutes();
 
    HttpFileserver &getFileHandler() { return fileServer; }
 
    void serveStatic(HttpRequest &req, HttpResponse &res, const RouteMatch &match);
 
    void listDirectory(HttpRequest &req, HttpResponse &res, const RouteMatch &match);
 
private:
    HttpFileserver fileServer; 
    std::unordered_map<std::string, std::vector<Route>> routes;
    Route catchallGetRoute;
    bool hasCatchallGetRoute = false; 
    std::string cached_token; 
    std::vector<Middleware> globalMiddleware;
    
    static StaticSemaphore_t lockBuffer_;
    SemaphoreHandle_t lock_ = xSemaphoreCreateRecursiveMutexStatic(&lockBuffer_);
 
    void withRoutes(const std::function<void(std::unordered_map<std::string, std::vector<Route>> &)> &fn);
};
 
#endif // ROUTER_HPP