webserver/source/shell/ResponseBuilder.cpp at main · LeaYeh/webserver · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
#include "ResponseBuilder.hpp"
#include "Config.hpp"
#include "TemplateEngine.hpp"
#include "defines.hpp"
#include "shellUtils.hpp"
#include "utils.hpp"
#include <string>

namespace webshell
{

ResponseBuilder::~ResponseBuilder() {}

Response ResponseBuilder::ok(StatusCode status_code,
                             const std::map<std::string, std::string>& headers,
                             const std::string& body,
                             bool body_only)
{
    Response response;

    if (body_only) {
        response.set_status_code(IGNORE);
        response.clear_headers();
        response.set_body(body);
    }
    else {
        response.set_status_code(status_code);
        response.set_headers(headers);
        response.set_body(body);
    }

    return (response);
}

Response ResponseBuilder::redirect(StatusCode status_code,
                                   const std::string& location)
{
    Response response;

    response.set_status_code(status_code);
    response.clear_headers();
    response.set_header("Content-Type", content_type_to_string(TEXT_PLAIN));
    response.set_header("Location", location);

    return (response);
}

Response ResponseBuilder::error(StatusCode status_code,
                                const std::string& description,
                                const ContentType& content_type)
{
    Response response;

    response.set_status_code(status_code);
    response.clear_headers();
    response.set_header("Content-Type", content_type_to_string(content_type));

    switch (content_type) {
    case TEXT_HTML:
        response.set_body(_render_error_page(status_code, description));
        break;
    case APPLICATION_JSON:
        response.set_body(_render_json(status_code, description));
        break;
    default:
        response.set_body(description);
        break;
    }

    return (response);
}

std::string ResponseBuilder::_render_error_page(StatusCode status_code,
                                                const std::string& message)
{
    static webkernel::TemplateEngine template_engine;

    try {
        template_engine.load_template(
            webconfig::Config::instance()->http_block().error_page());
        template_engine.set_variable("STATUS_CODE",
                                     utils::to_string(status_code));
        template_engine.set_variable("ERROR_REASON", message);

        return (template_engine.render());
    }
    catch (const std::exception& e) {
        // return (error(INTERNAL_SERVER_ERROR, e.what(), TEXT_PLAIN).body());
        return ("<!DOCTYPE html>\n"
                "<html>\n"
                "<head>\n"
                "<title>Error</title>\n"
                "</head>\n"
                "<body>\n"
                "<h1>Error "
                + utils::to_string(status_code)
                + "</h1>\n"
                  "<p>"
                + message
                + "</p>\n"
                  "</body>\n"
                  "</html>\n");
    }
}

std::string ResponseBuilder::_render_json(StatusCode status_code,
                                          const std::string& message)
{
    return ("{\"status_code\": " + utils::to_string(status_code)
            + ", \"message\": \"" + message + "\"}");
}

} // namespace webshell