handler.hpp

Go to the documentation of this file.

/*
 * Copyright 2020 Robert Bosch GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once
#ifndef CLOE_HANDLER_HPP_
#define CLOE_HANDLER_HPP_

#include <functional>  // for function
#include <map>         // for map, map<>::mapped_type
#include <string>      // for string, basic_string
#include <utility>     // for pair

#include <cloe/core.hpp>  // for Confable, Json

namespace cloe {

enum class RequestMethod {
  GET = 1,
  POST = 2,
  PUT = 4,
  DELETE = 8,
};

const char* as_cstr(const RequestMethod& m);
void from_string(const std::string& s, RequestMethod& m);

enum class ContentType {
  NOT_APPLICABLE,
  UNKNOWN,
  JSON,
  HTML,
  CSS,
  CSV,
  JAVASCRIPT,
  TEXT,
  SVG,
  PNG,
};

const char* as_cstr(const ContentType& t);

class Request {
 public:
  virtual ~Request() {}

  virtual RequestMethod method() const = 0;

  virtual ContentType type() const = 0;

  virtual const std::string& body() const = 0;

  virtual const std::string& uri() const = 0;

  virtual const std::string& endpoint() const = 0;

  virtual const std::map<std::string, std::string>& query_map() const = 0;

  virtual bool has_json() const { return this->type() == ContentType::JSON; }

  virtual Json as_json() const { return fable::parse_json(body()); }
};

enum class StatusCode {
  OK = 200,
  CREATED = 201,
  ACCEPTED = 202,
  NO_CONTENT = 204,
  RESET_CONTENT = 205,
  PARTIAL_CONTENT = 206,
  MULTIPLE_CHOICES = 300,
  MOVED_PERMANENTLY = 301,
  FOUND = 302,
  SEE_OTHER = 303,
  NOT_MODIFIED = 304,
  USE_PROXY = 305,
  TEMPORARY_REDIRECT = 307,
  BAD_REQUEST = 400,
  UNAUTHORIZED = 401,
  FORBIDDEN = 403,
  NOT_FOUND = 404,
  NOT_ALLOWED = 405,
  NOT_ACCEPTABLE = 406,
  REQUEST_TIMEOUT = 408,
  CONFLICT = 409,
  GONE = 410,
  SERVER_ERROR = 500,
  NOT_IMPLEMENTED = 501,
  SERVICE_UNAVAILABLE = 503,
};

class Response {
 public:
  Response() : status_(StatusCode::NO_CONTENT), type_(ContentType::NOT_APPLICABLE) {}

  const std::map<std::string, std::string>& headers() const { return headers_; }
  std::map<std::string, std::string>& headers() { return headers_; }

  bool has_header(const std::string& key) { return this->headers().count(key) != 0; }

  const std::string& header(const std::string& key) { return this->headers().at(key); }

  void set_header(const std::string& key, const std::string& value) {
    this->headers()[key] = value;
  }

  StatusCode status() const { return status_; }
  void set_status(StatusCode code) { status_ = code; }

  ContentType type() const { return type_; }
  void set_type(ContentType type) {
    type_ = type;
    this->set_header("Content-Type", as_cstr(type));
  }

  const std::string& body() const { return body_; }

  void set_body(const std::string& s, ContentType type) {
    if (!s.empty() && status_ == StatusCode::NO_CONTENT) {
      status_ = StatusCode::OK;
    }
    this->set_type(type);
    body_ = s;
  }

  void set_body(const Json& js) {
#ifdef NDEBUG
    this->set_body(js.dump(), ContentType::JSON);
#else
    this->set_body(js.dump(4), ContentType::JSON);
#endif
  }

  void write(const Json& js) { this->set_body(js); }

  void bad_request(const Json& js) { this->error(StatusCode::BAD_REQUEST, js); }

  void not_found(const Json& js) { this->error(StatusCode::NOT_FOUND, js); }

  void not_allowed(const RequestMethod& allow, const Json& js) {
    this->set_status(StatusCode::NOT_ALLOWED);
    this->set_header("Allow", as_cstr(allow));
    this->set_body(js);
  }

  void not_implemented(const Json& js) { this->error(StatusCode::NOT_IMPLEMENTED, js); }

  void server_error(const Json& js) { this->error(StatusCode::SERVER_ERROR, js); }

  void error(StatusCode code, const Json& js) {
    this->set_body(js);
    this->set_status(code);
  }

 private:
  StatusCode status_;
  ContentType type_;
  std::string body_;
  std::map<std::string, std::string> headers_;
};

using Handler = std::function<void(const Request&, Response&)>;

namespace handler {

class Redirect {
 public:
  explicit Redirect(const std::string& location) : location_(location) {}
  void operator()(const cloe::Request&, cloe::Response& r) {
    r.set_status(StatusCode::FOUND);
    r.set_header("Location", location_);
  }

 private:
  std::string location_;
};

class StaticJson {
 public:
  StaticJson(Json j) : data_(j) {}  // NOLINT
  void operator()(const cloe::Request&, cloe::Response& r) { r.write(data_); }

 private:
  const Json data_;
};

template <typename T>
class ToJson {
 public:
  explicit ToJson(const T* ptr) : ptr_(ptr) {}
  void operator()(const cloe::Request&, cloe::Response& r) {
    Json j;
    to_json(j, *ptr_);
    r.set_body(j);
  }

 private:
  const T* ptr_;
};

class FromConf {
 public:
  explicit FromConf(Confable* ptr, bool query_map_as_json = true)
      : ptr_(ptr), convert_(query_map_as_json) {}
  void operator()(const cloe::Request& q, cloe::Response& r);

 private:
  Confable* ptr_;
  bool convert_;
};

}  // namespace handler
}  // namespace cloe

#endif  // CLOE_HANDLER_HPP_