Controller.h

Go to the documentation of this file.

#ifndef HTTP_LIBRARY_CONTROLLER_H
#define HTTP_LIBRARY_CONTROLLER_H
 
#include <httplib.h>
 
#include <cstddef>
#include <exception>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <type_traits>
#include <vector>
 
#include "lintel/core/exceptions/HttpBadRequestException.h"
#include "lintel/core/services/LoggerService.h"
#include "lintel/core/utils/StringUtils.h"
#include "lintel/features/base/provider/GroupProvider.h"
#include "lintel/features/base/services/IAuthService.h"
#include "lintel/features/http/service/ClientIpResolver.h"
#include "lintel/features/http/service/ContentType.h"
#include "lintel/features/http/service/HttpStatusCodes.h"
 
 
#define ADD_HANDLER_METHOD(pattern, httpType, name)                                   \
  void name##httpType(const httplib::Request &request,                                \
    httplib::Response &response,                                                      \
    const lintel::ContentType &contentType,                                           \
    const std::optional<lintel::UserToken> &user);                                    \
  Handler name##httpType##Function = addMethod<std::function<HandlerArgs>, httpType>( \
    pattern, [&](const httplib::Request &request, httplib::Response &response) {      \
      std::string auth = request.get_header_value("Authorization");                   \
      std::string contentTypeString = request.get_header_value("Content-Type");       \
      if (contentTypeString.empty()) { contentTypeString = "application/json"; }      \
      lintel::ContentType contentType(contentTypeString);                             \
      std::optional<lintel::UserToken> user = std::nullopt;                           \
      try {                                                                           \
        if (lintel::StringUtils::startsWith(auth, "Bearer ") && auth.size() > 7) {    \
          std::string id = auth.substr(7);                                            \
          lintel::UserTokenLogin userTokenLogin{ clientIpOf(request), id };           \
          user = m_authService->onAccessOf(userTokenLogin);                           \
        }                                                                             \
        name##httpType(request, response, contentType, user);                         \
      } catch (const lintel::HttpBadRequestException &e) {                            \
        LOG_ERROR("{}: {}", #name, e.what());                                         \
        response.status = lintel::HttpStatusCodes::BadRequest;                        \
        response.set_content("bad request", "text/plain");                            \
      } catch (const std::exception &e) {                                             \
        LOG_ERROR("{}: {}", #name, e.what());                                         \
        response.status = lintel::HttpStatusCodes::InternalServerError;               \
        response.set_content("internal server error", "text/plain");                  \
      }                                                                               \
    })
 
#define ADD_HANDLER_CONTENT_READER_METHOD(pattern, httpType, name)                                                     \
  HandlerWithContentReader name##httpType##Function =                                                                  \
    addMethod<std::function<HandlerWithContentReaderArgs>, httpType>(pattern,                                          \
      [&](const httplib::Request &request, httplib::Response &response, const httplib::ContentReader &contentReader) { \
        const std::string contentTypeString = request.get_header_value("Content-Type");                                \
        lintel::ContentType contentType(contentTypeString);                                                            \
        try {                                                                                                          \
          name##httpType(request, response, contentReader, contentType);                                               \
        } catch (const std::exception &e) {                                                                            \
          LOG_ERROR("{}: {}", #name, e.what());                                                                        \
          response.status = lintel::HttpStatusCodes::InternalServerError;                                              \
          response.set_content("internal server error", "text/plain");                                                 \
        }                                                                                                              \
      });                                                                                                              \
  void name##httpType(const httplib::Request &request,                                                                 \
    httplib::Response &response,                                                                                       \
    const httplib::ContentReader &contentReader,                                                                       \
    const lintel::ContentType &contentType)
 
namespace lintel {
struct PagingParams
{
  static constexpr std::size_t kDefaultLimit = 100;
  bool m_enabled = false;
  std::optional<std::string> m_after;
  std::size_t m_limit = kDefaultLimit;
};
 
class Controller : public GroupProvider
{
protected:
  std::shared_ptr<IAuthService> m_authService;
 
  std::string clientIpOf(const httplib::Request &request);
 
  static PagingParams pagingParamsOf(const httplib::Request &request);
 
  ClientIpResolver m_ipResolver;
 
  using HandlerArgs = void(const httplib::Request &, httplib::Response &);
  using HandlerWithContentReaderArgs = void(const httplib::Request &,
    httplib::Response &,
    const httplib::ContentReader &);
  using Handler = std::function<HandlerArgs>;
  using HandlerWithContentReader = std::function<HandlerWithContentReaderArgs>;
 
  enum HttpType { Get, Put, Post, Delete };
 
  struct Method
  {
    const std::string m_pattern;
    std::shared_ptr<Handler> m_handler;
    std::shared_ptr<HandlerWithContentReader> m_handlerWithContentReader;
  };
 
  std::map<HttpType, std::vector<Method>> m_methods;
 
  template<class Type, HttpType httpType> Type addMethod(const std::string &pattern, Type handler)
  {
    const auto found = m_methods.find(httpType);
    static_assert(httpType != Get || !std::is_same_v<Type, HandlerWithContentReader>,
      "Get and HandlerWithContentReader is not supported");
    static_assert(std::is_same_v<Type, Handler> || std::is_same_v<Type, HandlerWithContentReader>,
      "Invalid method type! Pleas use Handler or "
      "HandlerWithContentReader");
    if constexpr (std::is_same_v<Type, Handler>) {
      const Method method{ pattern, std::make_shared<Type>(handler), nullptr };
      if (found != m_methods.end()) {
        found->second.push_back(method);
      } else {
        m_methods.insert({ httpType, std::vector<Method>{ method } });
      }
    } else if constexpr (std::is_same_v<Type, HandlerWithContentReader>) {
      const Method method{ pattern, nullptr, std::make_shared<Type>(handler) };
      if (found != m_methods.end()) {
        found->second.push_back(method);
      } else {
        m_methods.insert({ httpType, std::vector<Method>{ method } });
      }
    }
    return handler;
  }
 
public:
  explicit Controller(std::shared_ptr<IAuthService> authService)
    : GroupProvider(), m_authService(std::move(authService))
  {}
 
  ~Controller() override = default;
 
  void setTrustedProxies(std::vector<std::string> trustedProxies);
 
  void registerMethods(std::shared_ptr<httplib::Server> &server);
};
 
}// namespace lintel
#endif// HTTP_LIBRARY_CONTROLLER_H