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
 
#include <functional>  // for function
#include <map>         // for map
#include <string>      // for string
#include <utility>     // for pair
 
#include <fable/confable.hpp>  // for Confable
#include <fable/json.hpp>      // for 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 fable::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 fable::Json& js) {
#ifdef NDEBUG
    this->set_body(js.dump(), ContentType::JSON);
#else
    this->set_body(js.dump(4), ContentType::JSON);
#endif
  }
 
  void write(const fable::Json& js) { this->set_body(js); }
 
  void bad_request(const fable::Json& js) { this->error(StatusCode::BAD_REQUEST, js); }
 
  void not_found(const fable::Json& js) { this->error(StatusCode::NOT_FOUND, js); }
 
  void not_allowed(const RequestMethod& allow, const fable::Json& js) {
    this->set_status(StatusCode::NOT_ALLOWED);
    this->set_header("Allow", as_cstr(allow));
    this->set_body(js);
  }
 
  void not_implemented(const fable::Json& js) { this->error(StatusCode::NOT_IMPLEMENTED, js); }
 
  void server_error(const fable::Json& js) { this->error(StatusCode::SERVER_ERROR, js); }
 
  void error(StatusCode code, const fable::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(fable::Json j) : data_(j) {}  // NOLINT
  void operator()(const cloe::Request&, cloe::Response& r) { r.write(data_); }
 
 private:
  const fable::Json data_;
};
 
template <typename T>
class ToJson {
 public:
  explicit ToJson(const T* ptr) : ptr_(ptr) {}
  void operator()(const cloe::Request&, cloe::Response& r) {
    fable::Json j;
    to_json(j, *ptr_);
    r.set_body(j);
  }
 
 private:
  const T* ptr_;
};
 
class FromConf {
 public:
  explicit FromConf(fable::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:
  fable::Confable* ptr_;
  bool convert_;
};
 
}  // namespace handler
}  // namespace cloe